@rhizomatics/signalk-bluetti-plugin 1.0.8-alpha → 1.1.1-alpha

package/index.js

@@ -40,8 +40,8 @@ function builtinModelNames() {
 module.exports = function (app) {
   const log = (msg) => app.debug(msg);
 
-  let scanner       = null;
-  let activeDevices = [];
+  let scanner         = null;
+  let activeDevices   = [];
   let scanResultCache = [];
 
   const builtins = builtinModelNames();
@@ -185,17 +185,16 @@ module.exports = function (app) {
     const pending   = new Map(devices.map(cfg => [normalise(cfg.address), cfg]));
     const deps      = { BluettiDevice, loadCsv, buildDelta, readEncryptionKey };
 
-    scanner.on('discovered', ({ address, name, peripheral }) => {
+    scanner.on('discovered', ({ address, name, device: bleDevice }) => {
       scanResultCache.push({ address, name });
       const cfg = pending.get(normalise(address));
       if (cfg) {
         pending.delete(normalise(address));
         app.setPluginStatus(`Found ${name} [${address}] — connecting …`);
-        // Noble cannot scan and connect simultaneously — stop scan first.
-        // A short delay lets the BlueZ adapter finish scanning before we connect.
-        // The scanComplete handler will restart scanning for any remaining pending devices.
+        // Stop our discovery session before connecting (keeps the poll loop quiet).
+        // BlueZ handles scan+connect coexistence at the adapter level.
         scanner.stopScan();
-        setTimeout(() => startDevice(cfg, peripheral, name, deps), 500);
+        startDevice(cfg, bleDevice, name, deps);
       } else {
         log(`Discovered unconfigured Bluetti device: ${name} [${address}]`);
       }
@@ -257,7 +256,7 @@ module.exports = function (app) {
     return path.join(REGISTERS_DIR, `${builtinModel}.csv`);
   }
 
-  function startDevice(cfg, peripheral, bleName, { BluettiDevice, loadCsv, buildDelta, readEncryptionKey }) {
+  function startDevice(cfg, bleDevice, bleName, { BluettiDevice, loadCsv, buildDelta, readEncryptionKey }) {
     const { address, name, encryptionCsvPath = '', pollIntervalSeconds = 10 } = cfg;
 
     let registerPath;
@@ -300,7 +299,7 @@ module.exports = function (app) {
     const device = new BluettiDevice({
       address,
       name,
-      peripheral,
+      device: bleDevice,
       fields,
       pollIntervalMs: pollIntervalSeconds * 1000,
       xorKey,

package/lib/device.js

@@ -3,40 +3,40 @@
 const EventEmitter = require('events');
 const { buildReadRequest, completeFrameLength, parseReadResponse, applyXor, groupRegisters } = require('./protocol');
 
-// UUIDs used by most Bluetti devices (short form — noble strips dashes and lowercases)
-const SERVICE_UUID  = 'ff00';
-const NOTIFY_UUID   = 'ff01';
-const WRITE_UUID    = 'ff02';
+// UUIDs used by most Bluetti devices
+const SERVICE_UUID     = 'ff00';
+const NOTIFY_UUID      = 'ff01';
+const WRITE_UUID       = 'ff02';
 
 // Fallback UUIDs seen on some older/alternate firmwares
 const ALT_SERVICE_UUID = 'ffe0';
 const ALT_CHAR_UUID    = 'ffe1';
 
-const RECONNECT_DELAYS = [5000, 10000, 20000, 30000, 60000];  // ms, capped at last value
-const CONNECT_TIMEOUT_MS = 15000;
+const RECONNECT_DELAYS  = [5000, 10000, 20000, 30000, 60000];  // ms, capped at last value
+const CONNECT_TIMEOUT_MS = 30000;
 
 class BluettiDevice extends EventEmitter {
-  constructor({ address, name, peripheral, fields, pollIntervalMs = 10000, xorKey = null, log }) {
+  constructor({ address, name, device, fields, pollIntervalMs = 10000, xorKey = null, log }) {
     super();
-    this._address       = address;
-    this._name          = name;
-    this._peripheral    = peripheral;
-    this._fields        = fields;
+    this._address        = address;
+    this._name           = name;
+    this._device         = device;   // node-ble Device (D-Bus backed, persists across disconnects)
+    this._fields         = fields;
     this._pollIntervalMs = pollIntervalMs;
-    this._xorKey        = xorKey ? Buffer.from(xorKey, 'hex') : null;
-    this._log           = log;
-
-    this._connected     = false;
-    this._notifyChar    = null;
-    this._writeChar     = null;
-    this._rxBuf         = Buffer.alloc(0);
-    this._currentBatch  = null;   // { start, count } being awaited
-    this._batchQueue    = [];
-    this._pollTimer     = null;
-    this._reconnectAttempt = 0;
-    this._stopped       = false;
+    this._xorKey         = xorKey ? Buffer.from(xorKey, 'hex') : null;
+    this._log            = log;
+
+    this._connected          = false;
+    this._notifyChar         = null;
+    this._writeChar          = null;
+    this._rxBuf              = Buffer.alloc(0);
+    this._currentBatch       = null;   // { start, count } being awaited
+    this._batchQueue         = [];
+    this._pollTimer          = null;
+    this._reconnectAttempt   = 0;
+    this._stopped            = false;
+    this._disconnectHandler  = null;   // stored so we can remove it on reconnect
 
-    // Pre-compute register poll batches from field list
     const addrs = [...new Set(fields.flatMap(f => Array.from({ length: f.count }, (_, i) => f.register + i)))];
     this._batches = groupRegisters(addrs);
     this._log(`[${name}] Poll plan: ${this._batches.length} batch(es) covering ${addrs.length} registers`);
@@ -50,17 +50,32 @@ class BluettiDevice extends EventEmitter {
   stop() {
     this._stopped = true;
     this._stopPolling();
-    if (this._peripheral && this._connected) {
-      try { this._peripheral.disconnect(); } catch (_) {}
+    if (this._disconnectHandler) {
+      this._device.removeListener('disconnect', this._disconnectHandler);
+      this._disconnectHandler = null;
+    }
+    if (this._connected) {
+      this._device.disconnect().catch(() => {});
     }
   }
 
   // ── Connection lifecycle ─────────────────────────────────────────────────
 
-  _connect() {
+  async _connect() {
     if (this._stopped) return;
+    // Cancel any lingering BlueZ connection state (e.g. a previous attempt that
+    // timed out on our side but is still in progress inside BlueZ).
+    if (!this._connected) {
+      try { await this._device.disconnect(); } catch (_) {}
+    }
     this._log(`[${this._name}] Connecting to ${this._address} …`);
 
+    // Clear any stale disconnect handler from a previous attempt.
+    if (this._disconnectHandler) {
+      this._device.removeListener('disconnect', this._disconnectHandler);
+      this._disconnectHandler = null;
+    }
+
     let settled = false;
     const connectTimer = setTimeout(() => {
       if (settled) return;
@@ -69,66 +84,94 @@ class BluettiDevice extends EventEmitter {
       this._scheduleReconnect();
     }, CONNECT_TIMEOUT_MS);
 
-    this._peripheral.connect((err) => {
+    try {
+      await this._device.connect();
+    } catch (err) {
       if (settled) return;
       settled = true;
       clearTimeout(connectTimer);
-      if (err) {
-        this._log(`[${this._name}] Connect error: ${err.message}`);
-        this._scheduleReconnect();
-        return;
-      }
-      this._log(`[${this._name}] Connected`);
-      this._reconnectAttempt = 0;
-      this._discoverServices();
-    });
+      this._log(`[${this._name}] Connect error: ${err.message}`);
+      this._scheduleReconnect();
+      return;
+    }
 
-    this._peripheral.once('disconnect', () => {
+    if (settled) return;   // timed out while awaiting
+    settled = true;
+    clearTimeout(connectTimer);
+
+    this._log(`[${this._name}] Connected`);
+    this._reconnectAttempt = 0;
+
+    // Register disconnect handler — stored so it can be removed on reconnect.
+    this._disconnectHandler = () => {
       if (this._stopped) return;
-      this._connected = false;
-      this._notifyChar = null;
-      this._writeChar  = null;
+      this._connected          = false;
+      this._notifyChar         = null;
+      this._writeChar          = null;
+      this._disconnectHandler  = null;
       this._log(`[${this._name}] Disconnected`);
       this._stopPolling();
       this._scheduleReconnect();
-    });
+    };
+    this._device.once('disconnect', this._disconnectHandler);
+
+    await this._discoverServices();
   }
 
-  _discoverServices() {
-    this._peripheral.discoverAllServicesAndCharacteristics((err, _services, chars) => {
-      if (err) {
-        this._log(`[${this._name}] Service discovery error: ${err.message}`);
-        this._scheduleReconnect();
-        return;
-      }
-
-      const notifyChar = chars.find(c => c.uuid === NOTIFY_UUID) ||
-                         chars.find(c => c.uuid === ALT_CHAR_UUID);
-      const writeChar  = chars.find(c => c.uuid === WRITE_UUID)  ||
-                         chars.find(c => c.uuid === ALT_CHAR_UUID);
-
-      if (!notifyChar || !writeChar) {
-        const uuids = chars.map(c => c.uuid).join(', ');
-        this._log(`[${this._name}] Could not find required characteristics. Found: ${uuids}`);
-        this._scheduleReconnect();
-        return;
-      }
-
-      this._notifyChar = notifyChar;
-      this._writeChar  = writeChar;
-
-      notifyChar.subscribe((err) => {
-        if (err) {
-          this._log(`[${this._name}] Subscribe error: ${err.message}`);
-          this._scheduleReconnect();
-          return;
-        }
-        notifyChar.on('data', (data) => this._onData(data));
-        this._connected = true;
-        this.emit('connected');
-        this._startPolling();
-      });
-    });
+  async _discoverServices() {
+    let gatt;
+    try {
+      gatt = await this._device.gatt();
+    } catch (err) {
+      this._log(`[${this._name}] GATT error: ${err.message}`);
+      this._scheduleReconnect();
+      return;
+    }
+
+    let service;
+    for (const uuid of [SERVICE_UUID, ALT_SERVICE_UUID]) {
+      try {
+        service = await gatt.getPrimaryService(uuid);
+        break;
+      } catch (_) {}
+    }
+    if (!service) {
+      this._log(`[${this._name}] Could not find BLE service (tried ${SERVICE_UUID}, ${ALT_SERVICE_UUID})`);
+      this._scheduleReconnect();
+      return;
+    }
+
+    let notifyChar;
+    for (const uuid of [NOTIFY_UUID, ALT_CHAR_UUID]) {
+      try { notifyChar = await service.getCharacteristic(uuid); break; } catch (_) {}
+    }
+
+    let writeChar;
+    for (const uuid of [WRITE_UUID, ALT_CHAR_UUID]) {
+      try { writeChar = await service.getCharacteristic(uuid); break; } catch (_) {}
+    }
+
+    if (!notifyChar || !writeChar) {
+      this._log(`[${this._name}] Could not find required GATT characteristics`);
+      this._scheduleReconnect();
+      return;
+    }
+
+    try {
+      await notifyChar.startNotifications();
+    } catch (err) {
+      this._log(`[${this._name}] Subscribe error: ${err.message}`);
+      this._scheduleReconnect();
+      return;
+    }
+
+    notifyChar.on('valuechanged', (data) => this._onData(data));
+
+    this._notifyChar = notifyChar;
+    this._writeChar  = writeChar;
+    this._connected  = true;
+    this.emit('connected');
+    this._startPolling();
   }
 
   _scheduleReconnect() {
@@ -136,6 +179,8 @@ class BluettiDevice extends EventEmitter {
     const delay = RECONNECT_DELAYS[Math.min(this._reconnectAttempt, RECONNECT_DELAYS.length - 1)];
     this._reconnectAttempt++;
     this._log(`[${this._name}] Reconnecting in ${delay / 1000}s (attempt ${this._reconnectAttempt})`);
+    // The node-ble Device object is D-Bus backed and persists across disconnects —
+    // no need to rescan for a fresh peripheral; just call connect() again.
     setTimeout(() => {
       if (!this._stopped) this._connect();
     }, delay);
@@ -154,13 +199,12 @@ class BluettiDevice extends EventEmitter {
       clearInterval(this._pollTimer);
       this._pollTimer = null;
     }
-    this._batchQueue = [];
+    this._batchQueue   = [];
     this._currentBatch = null;
   }
 
   _poll() {
     if (!this._connected || this._batches.length === 0) return;
-    // Queue all batches; they'll be sent one at a time as responses arrive
     this._batchQueue = [...this._batches];
     this._rxBuf = Buffer.alloc(0);
     this._sendNextBatch();
@@ -173,20 +217,19 @@ class BluettiDevice extends EventEmitter {
     let frame = buildReadRequest(start, count);
     if (this._xorKey) frame = applyXor(frame, this._xorKey);
     this._rxBuf = Buffer.alloc(0);
-    this._writeChar.write(frame, false, (err) => {
-      if (err) this._log(`[${this._name}] Write error: ${err.message}`);
+    this._writeChar.writeValueWithoutResponse(frame).catch((err) => {
+      this._log(`[${this._name}] Write error: ${err.message}`);
     });
   }
 
   // ── Receive ──────────────────────────────────────────────────────────────
 
   _onData(data) {
-    // Undo XOR on incoming data if encryption is in use
     const chunk = this._xorKey ? applyXor(data, this._xorKey) : data;
     this._rxBuf = Buffer.concat([this._rxBuf, chunk]);
 
     const frameLen = completeFrameLength(this._rxBuf);
-    if (frameLen === 0) return;  // waiting for more BLE packets
+    if (frameLen === 0) return;   // waiting for more BLE packets
 
     const frame = this._rxBuf.slice(0, frameLen);
     this._rxBuf = this._rxBuf.slice(frameLen);
@@ -199,7 +242,6 @@ class BluettiDevice extends EventEmitter {
       this._log(`[${this._name}] CRC error or unexpected frame, skipping batch`);
     }
 
-    // Move to next batch
     this._sendNextBatch();
   }
 }

package/lib/scanner.js

@@ -2,105 +2,112 @@
 
 const EventEmitter = require('events');
 
-// Bluetti devices advertise with names matching these prefixes.
-// BT-TH-XXXXXXXXXX is the most common; some models use BLUETTI or model names directly.
 const BLUETTI_NAME_PREFIXES = ['BT-TH-', 'BLUETTI', 'AC', 'EP', 'EB', 'EL'];
 
-function isBluettiDevice(peripheral) {
-  const name = (peripheral.advertisement && peripheral.advertisement.localName) || '';
+function isBluettiDevice(name) {
+  if (!name) return false;
   return BLUETTI_NAME_PREFIXES.some(p => name.toUpperCase().startsWith(p.toUpperCase()));
 }
 
 class Scanner extends EventEmitter {
   constructor(log) {
     super();
-    this._log = log;
-    this._noble = null;
-    this._scanning = false;
-    this._found = new Map();   // address → peripheral
+    this._log       = log;
+    this._bluetooth = null;
+    this._destroy   = null;
+    this._adapter   = null;
+    this._scanning  = false;
+    this._scanTimer = null;
+    this._pollTimer = null;
+    this._found     = new Map();   // normalised address → { address, name, device }
   }
 
-  // Returns a promise that resolves once noble is powered on.
-  _initNoble() {
-    if (this._noble) return Promise.resolve();
-
-    return new Promise((resolve, reject) => {
-      let noble;
-      try {
-        noble = require('@stoprocent/noble');
-      } catch (e) {
-        return reject(new Error('@stoprocent/noble not installed — run: npm install'));
-      }
-
-      this._noble = noble;
-
-      noble.on('discover', (peripheral) => {
-        if (!isBluettiDevice(peripheral)) return;
-        const addr = peripheral.address || peripheral.id;
-        const name = (peripheral.advertisement.localName || 'unknown').trim();
-        if (!this._found.has(addr)) {
-          this._found.set(addr, peripheral);
-          this._log(`Discovered Bluetti device: ${name} [${addr}]`);
-          this.emit('discovered', { address: addr, name, peripheral });
-        }
-      });
-
-      noble.on('stateChange', (state) => {
-        this._log(`BLE adapter state: ${state}`);
-        if (state === 'poweredOn') {
-          resolve();
-        } else if (state === 'poweredOff' || state === 'unsupported') {
-          reject(new Error(`BLE adapter state: ${state}`));
-        }
-      });
-
-      // Already powered on (noble initialised before our listener)
-      if (noble.state === 'poweredOn') resolve();
-    });
+  async _init() {
+    if (this._adapter) return;
+    const { createBluetooth } = require('@naugehyde/node-ble');
+    const { bluetooth, destroy } = createBluetooth();
+    this._bluetooth = bluetooth;
+    this._destroy   = destroy;
+    this._adapter   = await bluetooth.defaultAdapter();
   }
 
   async startScan(durationMs = 15000) {
     if (this._scanning) return;
-    await this._initNoble();
+
+    try {
+      await this._init();
+    } catch (err) {
+      this._log(`BLE adapter init failed: ${err.message}`);
+      this.emit('error', err);
+      return;
+    }
+
     this._found.clear();
     this._scanning = true;
     this._log(`Scanning for Bluetti devices for ${durationMs / 1000}s …`);
-    this._noble.startScanning([], false);
+
+    try {
+      if (!await this._adapter.isDiscovering()) {
+        await this._adapter.startDiscovery();
+      }
+    } catch (err) {
+      this._log(`Failed to start BLE discovery: ${err.message}`);
+      this._scanning = false;
+      return;
+    }
+
     this._scanTimer = setTimeout(() => this.stopScan(), durationMs);
+    this._pollTimer = setInterval(() => this._poll(), 1000);
+    this._poll();   // check immediately for already-known devices
+  }
+
+  async _poll() {
+    if (!this._adapter || !this._scanning) return;
+    let addresses;
+    try {
+      addresses = await this._adapter.devices();
+    } catch (_) {
+      return;
+    }
+    for (const addr of addresses) {
+      if (!this._scanning) break;  // scanner stopped while we were iterating
+      const normAddr = addr.toLowerCase().replace(/:/g, '');
+      if (this._found.has(normAddr)) continue;
+      // Reserve the slot immediately to prevent concurrent _poll() calls from
+      // both processing the same address before either stores the device.
+      this._found.set(normAddr, null);
+      try {
+        const device = await this._adapter.getDevice(addr);
+        const name   = await Promise.resolve(device.getName()).catch(() => '') || '';
+        if (!this._scanning) break;
+        if (!isBluettiDevice(name)) { this._found.delete(normAddr); continue; }
+        this._found.set(normAddr, { address: addr, name, device });
+        this._log(`Discovered Bluetti device: ${name} [${addr}]`);
+        this.emit('discovered', { address: addr, name, device });
+      } catch (_) {
+        this._found.delete(normAddr);  // allow retry on transient D-Bus error
+      }
+    }
   }
 
   stopScan() {
     if (!this._scanning) return;
     clearTimeout(this._scanTimer);
+    clearInterval(this._pollTimer);
     this._scanning = false;
-    if (this._noble) this._noble.stopScanning();
+    // Decrement BlueZ discovery reference count — other plugins' sessions keep scanning.
+    if (this._adapter) this._adapter.stopDiscovery().catch(() => {});
     this._log(`Scan complete. Found ${this._found.size} Bluetti device(s).`);
-    this.emit('scanComplete', [...this._found.values()].map(p => ({
-      address: p.address || p.id,
-      name: (p.advertisement.localName || 'unknown').trim(),
-    })));
-  }
-
-  // Retrieve a previously-discovered peripheral by address (for reconnect).
-  getPeripheral(address) {
-    return this._found.get(address) || null;
-  }
-
-  // Start a persistent background scan (noble keeps discovering; don't auto-stop).
-  startPassiveScan() {
-    this._initNoble().then(() => {
-      this._scanning = true;
-      this._noble.startScanning([], true);   // allowDuplicates=true so we see RSSI updates
-    }).catch(err => {
-      this._log(`BLE init failed: ${err.message}`);
-      this.emit('error', err);
-    });
+    this.emit('scanComplete', [...this._found.values()].map(({ address, name }) => ({ address, name })));
   }
 
   stopAll() {
     this.stopScan();
-    if (this._noble) {
-      try { this._noble.stopScanning(); } catch (_) {}
+    if (this._destroy) {
+      try { this._destroy(); } catch (_) {}
+      this._destroy   = null;
+      this._adapter   = null;
+      this._bluetooth = null;
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhizomatics/signalk-bluetti-plugin",
-  "version": "1.0.8-alpha",
+  "version": "1.1.1-alpha",
   "signalk": {
     "displayName": "Bluetti Monitoring"
   },
@@ -30,7 +30,7 @@
     "start": "node index.js"
   },
   "dependencies": {
-    "@stoprocent/noble": "^2.5.3",
+    "@naugehyde/node-ble": "^1.13.5",
     "csv-parse": "^5.5.6"
   }
 }