@stoprocent/noble 1.19.0 → 2.0.0

package/examples/advertisement-discovery.js

@@ -1,65 +1,74 @@
 const noble = require('../index');
 
-noble.on('stateChange', function (state) {
-  if (state === 'poweredOn') {
-    noble.startScanning([], false);
-  } else {
-    noble.stopScanning();
-  }
-});
-
-noble.on('discover', function (peripheral) {
-  console.log(`${new Date()}`);
-  console.log(
-    `Peripheral discovered (${peripheral.id} with address <${peripheral.address}, ${peripheral.addressType}>, connectable: ${peripheral.connectable}, scannable: ${peripheral.scannable}, RSSI ${peripheral.rssi}:`
-  );
-  console.log('\thello my local name is:');
-  console.log(`\t\t${peripheral.advertisement.localName}`);
+async function handleDiscovery (peripheral) {
+  console.log(`\n${new Date()}`);
   console.log(
-    '\tcan I interest you in any of the following advertised services:'
+    `Peripheral discovered (${peripheral.id}):
+    - Address: ${peripheral.address} (${peripheral.addressType})
+    - Connectable: ${peripheral.connectable}
+    - Scannable: ${peripheral.scannable}
+    - RSSI: ${peripheral.rssi}`
   );
-  console.log(`\t\t${JSON.stringify(peripheral.advertisement.serviceUuids)}`);
-  const serviceData = peripheral.advertisement.serviceData;
 
+  // Local Name
+  if (peripheral.advertisement.localName) {
+    console.log(`Local Name: ${peripheral.advertisement.localName}`);
+  }
+
+  // Service UUIDs
+  if (peripheral.advertisement.serviceUuids.length) {
+    console.log('Advertised Services:');
+    console.log(`    ${peripheral.advertisement.serviceUuids.join(', ')}`);
+  }
+
+  // Service Data
+  const serviceData = peripheral.advertisement.serviceData;
   if (serviceData && serviceData.length) {
-    console.log('\there is my service data:');
-    for (const i in serviceData) {
-      console.log(
-        `\t\t${JSON.stringify(serviceData[i].uuid)}: ${JSON.stringify(
-          serviceData[i].data.toString('hex')
-        )}`
-      );
-    }
+    console.log('Service Data:');
+    serviceData.forEach(data => {
+      console.log(`    ${data.uuid}: ${data.data.toString('hex')}`);
+    });
   }
 
+  // Manufacturer Data
   if (peripheral.advertisement.manufacturerData) {
-    console.log('\there is my manufacturer data:');
-    console.log(
-      `\t\t${JSON.stringify(
-        peripheral.advertisement.manufacturerData.toString('hex')
-      )}`
-    );
+    console.log('Manufacturer Data:');
+    console.log(`    ${peripheral.advertisement.manufacturerData.toString('hex')}`);
   }
 
+  // TX Power Level
   if (peripheral.advertisement.txPowerLevel !== undefined) {
-    console.log('\tmy TX power level is:');
-    console.log(`\t\t${peripheral.advertisement.txPowerLevel}`);
+    console.log(`TX Power Level: ${peripheral.advertisement.txPowerLevel}`);
   }
+}
+
+async function main () {
+  try {
+    console.log('Waiting for Bluetooth adapter...');
+    await noble.waitForPoweredOnAsync();
+    console.log('Bluetooth adapter ready');
 
-  console.log();
-});
+    console.log('Starting scan for all devices...');
+    await noble.startScanningAsync([], false);
+    
+    noble.on('discover', handleDiscovery);
+    
+  } catch (error) {
+    throw new Error('Error:', error);
+  }
+}
 
-process.on('SIGINT', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+// Handle process termination
+const cleanup = async () => {
+  console.log('\nCleaning up...');
+  await noble.stopScanningAsync();
+  noble.stop();
+  console.log('noble stopped');
+};
 
-process.on('SIGQUIT', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+process.on('SIGINT', cleanup);
+process.on('SIGQUIT', cleanup);
+process.on('SIGTERM', cleanup);
 
-process.on('SIGTERM', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+// Start the application
+main().catch(console.error);

package/examples/connect-address.js

@@ -1,40 +1,65 @@
 const noble = require('../index');
-const direct = require('debug')('connection/direct');
-const scan = require('debug')('connection/scan');
 
-function sleep (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
+async function main () {
+  try {
+    // Wait for the BLE adapter to be ready
+    console.log('Waiting for powered on state');
+    await noble.waitForPoweredOnAsync();
+    console.log('Powered on');
 
-async function run () {
-  noble.on('stateChange', async function (state) {
-    if (state === 'poweredOn') {
-      try {
-        direct('connecting');
-        // const uuid = 'f1:36:1c:ab:94:cc'.split(':').join(''); // HCI Address UUID
-        const uuid = '2561b846d6f83ee27580bca8ed6ec079'; // MacOS UUID
-        const peripheral = await noble.connectAsync(uuid);
-        direct(`connected ${peripheral.uuid}`);
-        await peripheral.disconnectAsync();
-        direct('disconnected');
-        console.log('sleeping for 2000ms');
-        await sleep(2000);
-        scan('connecting by scan');
-        await noble.startScanningAsync();
-        noble.on('discover', async peripheral => {
-          if (peripheral.uuid === uuid) {
-            await noble.stopScanningAsync();
-            await peripheral.connectAsync();
-            scan(`connected ${peripheral.uuid}`);
-            await peripheral.disconnectAsync();
-            scan('disconnected');
-          }
-        });
-      } catch (error) {
-        console.log(error);
-      }
+    // First attempt - direct connection
+    const uuid = '2561b846d6f83ee27580bca8ed6ec079'; // MacOS UUID
+    console.log('Attempting direct connection to:', uuid);
+    
+    try {
+      const peripheral = await noble.connectAsync(uuid);
+      console.log('Direct connection successful to:', peripheral.id);
+      await peripheral.disconnectAsync();
+      console.log('Disconnected from direct connection');
+    } catch (error) {
+      console.log('Direct connection failed:', error.message);
     }
-  });
+
+    // Wait before trying scan method
+    console.log('Waiting 2 seconds before scan attempt...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Second attempt - scan and connect
+    console.log('Starting scan for device');
+    await noble.startScanningAsync();
+
+    noble.on('discover', async (peripheral) => {
+      if (peripheral.id === uuid) {
+        console.log('Found device in scan:', peripheral.id);
+        await noble.stopScanningAsync();
+        
+        try {
+          await peripheral.connectAsync();
+          console.log('Scan connection successful to:', peripheral.id);
+          await peripheral.disconnectAsync();
+          console.log('Disconnected from scan connection');
+        } catch (error) {
+          console.log('Scan connection failed:', error.message);
+        }
+      }
+    });
+
+  } catch (error) {
+    console.error('Main error:', error);
+  }
 }
 
-run();
+// Handle process termination
+const cleanup = async () => {
+  console.log('Caught interrupt signal');
+  await noble.stopScanningAsync();
+  noble.stop();
+  console.log('noble stopped');
+};
+
+process.on('SIGINT', cleanup);
+process.on('SIGQUIT', cleanup);
+process.on('SIGTERM', cleanup);
+
+// Start the application
+main().catch(console.error);

package/examples/echo.js

@@ -11,94 +11,84 @@ const noble = require('..');
 const ECHO_SERVICE_UUID = 'ec00';
 const ECHO_CHARACTERISTIC_UUID = 'ec0e';
 
-noble.on('stateChange', (state) => {
-  if (state === 'poweredOn') {
+async function main () {
+  try {
+    // Wait for the BLE adapter to be ready
+    console.log('Waiting for powered on');
+    await noble.waitForPoweredOnAsync();
+    console.log('Powered on');
+    await noble.setAddress('11:22:33:44:55:66');
+    console.log('Set address');
+    await noble.startScanningAsync([ECHO_SERVICE_UUID], false);
     console.log('Scanning');
-    noble.startScanning([ECHO_SERVICE_UUID], false);
-  } else {
-    noble.stopScanning();
+  } catch (error) {
+    throw new Error('Error initializing BLE:', error);
   }
-});
+}
 
-noble.on('discover', (peripheral) => {
+noble.on('discover', async (peripheral) => {
   // connect to the first peripheral that is scanned
-  noble.stopScanning();
+  await noble.stopScanningAsync();
   const name = peripheral.advertisement.localName;
   console.log(`Connecting to '${name}' ${peripheral.id}`);
   connectAndSetUp(peripheral);
 });
 
-function connectAndSetUp (peripheral) {
-  peripheral.connect((error) => {
-    if (error) {
-      console.error(error);
-      return;
-    }
-
+async function connectAndSetUp (peripheral) {
+  try {
+    await peripheral.connectAsync();
     console.log('Connected to', peripheral.id);
 
-    // specify the services and characteristics to discover
-    const serviceUUIDs = [ECHO_SERVICE_UUID];
-    const characteristicUUIDs = [ECHO_CHARACTERISTIC_UUID];
-
-    peripheral.discoverSomeServicesAndCharacteristics(
-      serviceUUIDs,
-      characteristicUUIDs,
-      onServicesAndCharacteristicsDiscovered
+    // // specify the services and characteristics to discover
+    const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync(
+      [ECHO_SERVICE_UUID],
+      [ECHO_CHARACTERISTIC_UUID]
     );
-  });
-
-  peripheral.on('disconnect', () => console.log('disconnected'));
-}
-
-function onServicesAndCharacteristicsDiscovered (
-  error,
-  services,
-  characteristics
-) {
-  if (error) {
-    console.error(error);
-    return;
-  }
 
-  console.log('Discovered services and characteristics');
-  const echoCharacteristic = characteristics[0];
+    console.log('Discovered services and characteristics');
+    const echoCharacteristic = characteristics[0];
 
-  // data callback receives notifications
-  echoCharacteristic.on('data', (data, isNotification) => {
-    console.log(`Received: "${data}"`);
-  });
+    // data callback receives notifications
+    echoCharacteristic.on('read', (data, isNotification) => {
+      console.log(`Received: "${data}"`);
+    });
 
-  // subscribe to be notified whenever the peripheral update the characteristic
-  echoCharacteristic.subscribe((error) => {
-    if (error) {
-      console.error('Error subscribing to echoCharacteristic');
-    } else {
+    // subscribe to be notified whenever the peripheral update the characteristic
+    try {
+      await echoCharacteristic.subscribeAsync();
       console.log('Subscribed for echoCharacteristic notifications');
+    } catch (error) {
+      console.error('Error subscribing to echoCharacteristic:', error);
+      return;
     }
-  });
-
-  // create an interval to send data to the service
-  let count = 0;
-  setInterval(() => {
-    count++;
-    const message = Buffer.from(`hello, ble ${count}`, 'utf-8');
-    console.log(`Sending:  '${message}'`);
-    echoCharacteristic.write(message);
-  }, 2500);
+
+    // create an interval to send data to the service
+    let count = 0;
+    setInterval(async () => {
+      count++;
+      const message = Buffer.from(`hello, ble ${count}`, 'utf-8');
+      console.log(`Sending:  '${message}'`);
+      await echoCharacteristic.writeAsync(message, false);
+    }, 2500);
+
+  } catch (error) {
+    console.error('Error during connection setup:', error);
+  }
+
+  peripheral.on('disconnect', () => console.log('disconnected'));
 }
 
-process.on('SIGINT', function () {
+// Handle process termination
+const cleanup = async () => {
   console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+  await noble.stopScanningAsync();
+  noble.stop();
+  console.log('noble stopped');
+};
 
-process.on('SIGQUIT', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+process.on('SIGINT', cleanup);
+process.on('SIGQUIT', cleanup);
+process.on('SIGTERM', cleanup);
 
-process.on('SIGTERM', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+// Start the application
+main().catch(console.error);

package/examples/enter-exit.js

@@ -1,4 +1,5 @@
-/* eslint-disable handle-callback-err */
+const noble = require('../index');
+
 /*
   Continuously scans for peripherals and prints out message when they enter/exit
 
@@ -7,38 +8,54 @@
 
   based on code provided by: Mattias Ask (http://www.dittlof.com)
 */
-const noble = require('../index');
 
-const RSSI_THRESHOLD = -90;
+const RSSI_THRESHOLD = -50;
 const EXIT_GRACE_PERIOD = 2000; // milliseconds
 
-const inRange = [];
-
-noble.on('discover', function (peripheral) {
-  if (peripheral.rssi < RSSI_THRESHOLD) {
-    // ignore
-    return;
-  }
-
-  const id = peripheral.id;
-  const entered = !inRange[id];
-
-  if (entered) {
-    inRange[id] = {
-      peripheral
-    };
-
-    console.log(
-      `"${peripheral.advertisement.localName}" entered (RSSI ${
-        peripheral.rssi
-      }) ${new Date()}`
-    );
+const inRange = {};
+
+// Self-executing async function
+(async function () {
+  try {
+    // Initialize noble
+    await noble.waitForPoweredOnAsync();
+    console.log('noble started');
+
+    // Start scanning
+    await noble.startScanningAsync([], true);
+    console.log('Scanning for peripherals...');
+
+    // Continuously discover peripherals
+    for await (const peripheral of noble.discoverAsync()) {
+      if (peripheral.rssi < RSSI_THRESHOLD) {
+        // ignore devices with weak signal
+        continue;
+      }
+
+      const id = peripheral.id;
+      const entered = !inRange[id];
+
+      if (entered) {
+        inRange[id] = {
+          peripheral
+        };
+
+        console.log(
+          `"${peripheral.advertisement.localName}" entered (RSSI ${
+            peripheral.rssi
+          }) ${new Date()}`
+        );
+      }
+
+      inRange[id].lastSeen = Date.now();
+    }
+  } catch (error) {
+    throw new Error('Error:', error);
   }
+})();
 
-  inRange[id].lastSeen = Date.now();
-});
-
-setInterval(function () {
+// Check for peripherals that have left range
+setInterval(() => {
   for (const id in inRange) {
     if (inRange[id].lastSeen < Date.now() - EXIT_GRACE_PERIOD) {
       const peripheral = inRange[id].peripheral;
@@ -54,25 +71,14 @@ setInterval(function () {
   }
 }, EXIT_GRACE_PERIOD / 2);
 
-noble.on('stateChange', function (state) {
-  if (state === 'poweredOn') {
-    noble.startScanning([], true);
-  } else {
-    noble.stopScanning();
-  }
-});
-
-process.on('SIGINT', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
-
-process.on('SIGQUIT', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
-
-process.on('SIGTERM', function () {
+// Handle process termination
+const cleanup = async () => {
   console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+  await noble.stopScanningAsync();
+  noble.stop();
+  console.log('noble stopped');
+};
+
+process.on('SIGINT', cleanup);
+process.on('SIGQUIT', cleanup);
+process.on('SIGTERM', cleanup);

package/examples/multiple-bindings.js

@@ -0,0 +1,53 @@
+const { withBindings } = require('../index');
+
+const nobleUartA = withBindings('hci', { 
+  hciDriver: 'uart', 
+    bindParams: { 
+        uart: { 
+            port: '/dev/tty.usbmodem1474201' 
+        } 
+    } 
+});
+
+const nobleUartB = withBindings('hci', { 
+  hciDriver: 'uart', 
+    bindParams: { 
+        uart: { 
+            port: '/dev/tty.usbmodem1474401' 
+        } 
+    } 
+});
+
+const nobleUartC = withBindings('default');
+
+nobleUartA.on('discover', peripheral => {
+  console.log('UART A', peripheral.id);
+});
+
+nobleUartB.on('discover', peripheral => {
+  console.log('UART B', peripheral.id);
+});
+
+nobleUartC.on('discover', peripheral => {
+  console.log('UART C', peripheral.id);
+});
+
+nobleUartA.on('stateChange', state => {
+  if (state === 'poweredOn') {
+    nobleUartA.setAddress('00:11:22:33:44:01');
+    nobleUartA.startScanning([], true);
+  }
+});
+
+nobleUartB.on('stateChange', state => {
+  if (state === 'poweredOn') {
+    nobleUartB.setAddress('00:11:22:33:44:02');
+    nobleUartB.startScanning([], true);
+  }
+});
+
+nobleUartC.on('stateChange', state => {
+  if (state === 'poweredOn') {
+    nobleUartC.startScanning([], true);
+  }
+});

package/examples/peripheral-explorer-async.js

@@ -1,22 +1,37 @@
 const noble = require('../');
 
-const directConnect = process.argv[2].toLowerCase();
-const peripheralIdOrAddress = process.argv[3].toLowerCase();
-const addressType = process.argv[4].toLowerCase() || 'random';
+let directConnect = '0';
+let peripheralIdOrAddress = 'cd:6b:86:03:39:40'.toLowerCase();
+let addressType = 'random';
+
+try {
+  directConnect = process.argv[2].toLowerCase() || '0';
+  peripheralIdOrAddress = process.argv[3].toLowerCase() || 'cd:6b:86:03:39:40';
+  addressType = process.argv[4].toLowerCase() || 'random';
+} catch (error) {
+  console.error('Error:', error);
+}
 
 const starTime = Date.now();
 
+let peripheral;
 async function main () {
   try {
-    await noble.waitForPoweredOn();
+    await noble.waitForPoweredOnAsync();
+
+    // Cancel the connection after 5 seconds if it is still connecting
+    setTimeout(() => {
+      noble.cancelConnect(peripheralIdOrAddress);
+    }, 5000);
+
     if (directConnect === '1') {
-      const peripheral = await noble.connectAsync(peripheralIdOrAddress.replace(/:/g, ''), { addressType });
+      peripheral = await noble.connectAsync(peripheralIdOrAddress, { addressType });
       await explore(peripheral);
     } else {
-      await noble.startScanningAsync();
+      await noble.startScanningAsync([], false);
     }
   } catch (error) {
-    console.error('Error:', error);
+    throw new Error('Error:', error);
   }
 }
 
@@ -28,6 +43,7 @@ noble.on('discover', async (peripheral) => {
     await noble.stopScanningAsync();
     
     console.log(`Peripheral with ID ${peripheral.id} found`);
+
     const advertisement = peripheral.advertisement;
 
     const localName = advertisement.localName;
@@ -70,14 +86,19 @@ noble.on('discover', async (peripheral) => {
 const explore = async (peripheral) => {
   console.log('Services and characteristics:');
 
-  peripheral.on('disconnect', () => {
-    process.exit(0);
+  peripheral.on('disconnect', (reason) => {
+    console.log('Disconnected', reason);
+    noble.stop();
+    console.log('noble stopped');
   });
 
   if (peripheral.state !== 'connected') {
     await peripheral.connectAsync();
   }
 
+  const rssi = await peripheral.updateRssiAsync();
+  console.log('RSSI', rssi);
+
   const services = await peripheral.discoverServicesAsync([]);
 
   for (const service of services) {
@@ -136,19 +157,16 @@ const explore = async (peripheral) => {
 
 };
 
-process.on('SIGINT', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
-
-process.on('SIGQUIT', function () {
+// Handle process termination
+const cleanup = async () => {
   console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+  await noble.stopScanningAsync();
+  noble.stop();
+  console.log('noble stopped');
+};
 
-process.on('SIGTERM', function () {
-  console.log('Caught interrupt signal');
-  noble.stopScanning(() => process.exit());
-});
+process.on('SIGINT', cleanup);
+process.on('SIGQUIT', cleanup);
+process.on('SIGTERM', cleanup);
 
 main();