@stoprocent/noble 1.9.2-16

package/examples/peripheral-explorer-async.js

@@ -0,0 +1,133 @@
+const noble = require('../')({ extended: false });
+
+const peripheralIdOrAddress = process.argv[2].toLowerCase();
+
+noble.on('stateChange', async (state) => {
+  if (state === 'poweredOn') {
+    await noble.startScanningAsync([], false);
+  }
+});
+
+noble.on('discover', async (peripheral) => {
+  if ([peripheral.id, peripheral.address].includes(peripheralIdOrAddress)) {
+    await noble.stopScanningAsync();
+
+    console.log(`Peripheral with ID ${peripheral.id} found`);
+    const advertisement = peripheral.advertisement;
+
+    const localName = advertisement.localName;
+    const txPowerLevel = advertisement.txPowerLevel;
+    const manufacturerData = advertisement.manufacturerData;
+    const serviceData = advertisement.serviceData;
+    const serviceUuids = advertisement.serviceUuids;
+
+    if (localName) {
+      console.log(`  Local Name        = ${localName}`);
+    }
+
+    if (txPowerLevel) {
+      console.log(`  TX Power Level    = ${txPowerLevel}`);
+    }
+
+    if (manufacturerData) {
+      console.log(`  Manufacturer Data = ${manufacturerData.toString('hex')}`);
+    }
+
+    if (serviceData) {
+      console.log(
+        `  Service Data      = ${JSON.stringify(serviceData, null, 2)}`
+      );
+    }
+
+    if (serviceUuids) {
+      console.log(`  Service UUIDs     = ${serviceUuids}`);
+    }
+
+    console.log();
+
+    await explore(peripheral);
+  }
+});
+
+/**
+ * @param {import('../').Peripheral} peripheral
+ */
+const explore = async (peripheral) => {
+  console.log('Services and characteristics:');
+
+  peripheral.on('disconnect', () => {
+    process.exit(0);
+  });
+
+  await peripheral.connectAsync();
+
+  const services = await peripheral.discoverServicesAsync([]);
+
+  for (const service of services) {
+    let serviceInfo = service.uuid;
+
+    if (service.name) {
+      serviceInfo += ` (${service.name})`;
+    }
+
+    console.log(serviceInfo);
+
+    const characteristics = await service.discoverCharacteristicsAsync([]);
+
+    for (const characteristic of characteristics) {
+      let characteristicInfo = `  ${characteristic.uuid}`;
+
+      if (characteristic.name) {
+        characteristicInfo += ` (${characteristic.name})`;
+      }
+
+      const descriptors = await characteristic.discoverDescriptorsAsync();
+
+      const userDescriptionDescriptor = descriptors.find(
+        (descriptor) => descriptor.uuid === '2901'
+      );
+
+      if (userDescriptionDescriptor) {
+        const data = await userDescriptionDescriptor.readValueAsync();
+        if (data) {
+          characteristicInfo += ` (${data.toString()})`;
+        }
+      }
+
+      characteristicInfo += `\n    properties  ${characteristic.properties.join(
+        ', '
+      )}`;
+
+      if (characteristic.properties.includes('read')) {
+        const data = await characteristic.readAsync();
+
+        if (data) {
+          const string = data.toString('ascii');
+
+          characteristicInfo += `\n    value       ${data.toString(
+            'hex'
+          )} | '${string}'`;
+        }
+      }
+
+      console.log(characteristicInfo);
+    }
+  }
+
+  await peripheral.disconnectAsync();
+};
+
+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 () {
+  console.log('Caught interrupt signal');
+  noble.stopScanning(() => process.exit());
+});

package/examples/peripheral-explorer.js

@@ -0,0 +1,225 @@
+/* eslint-disable handle-callback-err */
+const async = require('async');
+const noble = require('../index')({ extended: false });
+
+const peripheralIdOrAddress = process.argv[2].toLowerCase();
+
+noble.on('stateChange', function (state) {
+  if (state === 'poweredOn') {
+    noble.startScanning([], false);
+  } else {
+    noble.stopScanning();
+  }
+});
+
+noble.on('discover', function (peripheral) {
+  if (
+    peripheral.id === peripheralIdOrAddress ||
+    peripheral.address === peripheralIdOrAddress
+  ) {
+    noble.stopScanning();
+
+    console.log(`peripheral with ID ${peripheral.id} found`);
+    const advertisement = peripheral.advertisement;
+
+    const localName = advertisement.localName;
+    const txPowerLevel = advertisement.txPowerLevel;
+    const manufacturerData = advertisement.manufacturerData;
+    const serviceData = advertisement.serviceData;
+    const serviceUuids = advertisement.serviceUuids;
+
+    if (localName) {
+      console.log(`  Local Name        = ${localName}`);
+    }
+
+    if (txPowerLevel) {
+      console.log(`  TX Power Level    = ${txPowerLevel}`);
+    }
+
+    if (manufacturerData) {
+      console.log(`  Manufacturer Data = ${manufacturerData.toString('hex')}`);
+    }
+
+    if (serviceData) {
+      console.log(
+        `  Service Data      = ${JSON.stringify(serviceData, null, 2)}`
+      );
+    }
+
+    if (serviceUuids) {
+      console.log(`  Service UUIDs     = ${serviceUuids}`);
+    }
+
+    console.log();
+
+    explore(peripheral);
+  }
+});
+
+function explore (peripheral) {
+  console.log('services and characteristics:');
+
+  peripheral.on('disconnect', function () {
+    process.exit(0);
+  });
+
+  peripheral.connect(function (error) {
+    if (error) {
+      console.error(error);
+      return;
+    }
+
+    peripheral.discoverServices([], function (error, services) {
+      if (error) {
+        console.error(error);
+        return;
+      }
+
+      let serviceIndex = 0;
+
+      async.whilst(
+        function () {
+          return serviceIndex < services.length;
+        },
+        function (callback) {
+          const service = services[serviceIndex];
+          let serviceInfo = service.uuid;
+
+          if (service.name) {
+            serviceInfo += ` (${service.name})`;
+          }
+          console.log(serviceInfo);
+
+          service.discoverCharacteristics(
+            [],
+            function (error, characteristics) {
+              if (error) {
+                console.error(error);
+                return;
+              }
+
+              let characteristicIndex = 0;
+
+              async.whilst(
+                function () {
+                  return characteristicIndex < characteristics.length;
+                },
+                function (callback) {
+                  const characteristic = characteristics[characteristicIndex];
+                  let characteristicInfo = `  ${characteristic.uuid}`;
+
+                  if (characteristic.name) {
+                    characteristicInfo += ` (${characteristic.name})`;
+                  }
+
+                  async.series([
+                    function (callback) {
+                      characteristic.discoverDescriptors(function (
+                        error,
+                        descriptors
+                      ) {
+                        if (error) {
+                          console.error(error);
+                          return;
+                        }
+
+                        async.detect(
+                          descriptors,
+                          function (descriptor, callback) {
+                            if (descriptor.uuid === '2901') {
+                              return callback(descriptor);
+                            } else {
+                              return callback();
+                            }
+                          },
+                          function (userDescriptionDescriptor) {
+                            if (userDescriptionDescriptor) {
+                              userDescriptionDescriptor.readValue(function (
+                                error,
+                                data
+                              ) {
+                                if (error) {
+                                  console.error(error);
+                                }
+
+                                if (data) {
+                                  characteristicInfo += ` (${data.toString()})`;
+                                }
+                                callback();
+                              });
+                            } else {
+                              callback();
+                            }
+                          }
+                        );
+                      });
+                    },
+                    function (callback) {
+                      characteristicInfo += `\n    properties  ${characteristic.properties.join(
+                        ', '
+                      )}`;
+
+                      if (characteristic.properties.indexOf('read') !== -1) {
+                        characteristic.read(function (error, data) {
+                          if (error) {
+                            console.error(error);
+                          }
+
+                          if (data) {
+                            const string = data.toString('ascii');
+
+                            characteristicInfo += `\n    value       ${data.toString(
+                              'hex'
+                            )} | '${string}'`;
+                          }
+                          callback();
+                        });
+                      } else {
+                        callback();
+                      }
+                    },
+                    function () {
+                      console.log(characteristicInfo);
+                      characteristicIndex++;
+                      callback();
+                    }
+                  ]);
+                },
+                function (error) {
+                  if (error) {
+                    console.error(error);
+                  }
+
+                  serviceIndex++;
+                  callback();
+                }
+              );
+            }
+          );
+        },
+        function (error) {
+          if (error) {
+            console.error(error);
+          }
+
+          peripheral.disconnect();
+        }
+      );
+    });
+  });
+}
+
+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 () {
+  console.log('Caught interrupt signal');
+  noble.stopScanning(() => process.exit());
+});

package/examples/pizza/README.md

@@ -0,0 +1,15 @@
+# BLE Pizza Service
+
+This is an example program demonstrating BLE connectivity between a peripheral running bleno, and a central running noble.
+
+This central connects to a robotic pizza oven service, with the following characteristics:
+
+* crust - read / write. A value representing the type of pizza crust (normal, thin, or deep dish)
+* toppings - read / write. A value representing which toppings to include (pepperoni, mushrooms, extra cheese, etc.)
+* bake - write / notify. The value written is the temperature at which to bake the pizza. When baking is finished, the central is notified with a bake result (half baked, crispy, burnt, etc.)
+
+To run the central example:
+
+    node central
+
+And on another computer, start advertising a peripheral with [bleno](https://github.com/sandeepmistry/bleno/tree/master/examples/pizza).

package/examples/pizza/central.js

@@ -0,0 +1,194 @@
+/* eslint-disable handle-callback-err */
+const noble = require('../..')({ extended: false });
+const pizza = require('./pizza');
+
+const pizzaServiceUuid = '13333333333333333333333333333337';
+const pizzaCrustCharacteristicUuid = '13333333333333333333333333330001';
+const pizzaToppingsCharacteristicUuid = '13333333333333333333333333330002';
+const pizzaBakeCharacteristicUuid = '13333333333333333333333333330003';
+
+noble.on('stateChange', function (state) {
+  if (state === 'poweredOn') {
+    //
+    // Once the BLE radio has been powered on, it is possible
+    // to begin scanning for services. Pass an empty array to
+    // scan for all services (uses more time and power).
+    //
+    console.log('scanning...');
+    noble.startScanning([pizzaServiceUuid], false);
+  } else {
+    noble.stopScanning();
+  }
+});
+
+let pizzaCrustCharacteristic = null;
+let pizzaToppingsCharacteristic = null;
+let pizzaBakeCharacteristic = null;
+
+noble.on('discover', function (peripheral) {
+  // we found a peripheral, stop scanning
+  noble.stopScanning();
+
+  //
+  // The advertisment data contains a name, power level (if available),
+  // certain advertised service uuids, as well as manufacturer data,
+  // which could be formatted as an iBeacon.
+  //
+  console.log('found peripheral:', peripheral.advertisement);
+  //
+  // Once the peripheral has been discovered, then connect to it.
+  //
+  peripheral.connect(function (error) {
+    if (error) {
+      console.error(error);
+    }
+
+    //
+    // Once the peripheral has been connected, then discover the
+    // services and characteristics of interest.
+    //
+    peripheral.discoverServices([pizzaServiceUuid], function (error, services) {
+      if (error) {
+        console.error(error);
+        return;
+      }
+
+      services.forEach(function (service) {
+        //
+        // This must be the service we were looking for.
+        //
+        console.log('found service:', service.uuid);
+
+        //
+        // So, discover its characteristics.
+        //
+        service.discoverCharacteristics([], function (error, characteristics) {
+          if (error) {
+            console.error(error);
+            return;
+          }
+
+          characteristics.forEach(function (characteristic) {
+            //
+            // Loop through each characteristic and match them to the
+            // UUIDs that we know about.
+            //
+            console.log('found characteristic:', characteristic.uuid);
+
+            if (pizzaCrustCharacteristicUuid === characteristic.uuid) {
+              pizzaCrustCharacteristic = characteristic;
+            } else if (
+              pizzaToppingsCharacteristicUuid === characteristic.uuid
+            ) {
+              pizzaToppingsCharacteristic = characteristic;
+            } else if (pizzaBakeCharacteristicUuid === characteristic.uuid) {
+              pizzaBakeCharacteristic = characteristic;
+            }
+          });
+
+          //
+          // Check to see if we found all of our characteristics.
+          //
+          if (
+            pizzaCrustCharacteristic &&
+            pizzaToppingsCharacteristic &&
+            pizzaBakeCharacteristic
+          ) {
+            //
+            // We did, so bake a pizza!
+            //
+            bakePizza();
+          } else {
+            console.log('missing characteristics');
+          }
+        });
+      });
+    });
+  });
+});
+
+function bakePizza () {
+  //
+  // Pick the crust.
+  //
+  const crust = Buffer.alloc(1);
+  crust.writeUInt8(pizza.PizzaCrust.THIN, 0);
+  pizzaCrustCharacteristic.write(crust, false, function (err) {
+    if (!err) {
+      //
+      // Pick the toppings.
+      //
+      const toppings = Buffer.alloc(2);
+      toppings.writeUInt16BE(
+        pizza.PizzaToppings.EXTRA_CHEESE |
+          pizza.PizzaToppings.CANADIAN_BACON |
+          pizza.PizzaToppings.PINEAPPLE,
+        0
+      );
+      pizzaToppingsCharacteristic.write(toppings, false, function (err) {
+        if (!err) {
+          //
+          // Subscribe to the bake notification, so we know when
+          // our pizza will be ready.
+          //
+          pizzaBakeCharacteristic.on('read', function (data, isNotification) {
+            console.log('Our pizza is ready!');
+            if (data.length === 1) {
+              const result = data.readUInt8(0);
+              console.log('The result is',
+                result === pizza.PizzaBakeResult.HALF_BAKED
+                  ? 'half baked.'
+                  : result === pizza.PizzaBakeResult.BAKED
+                    ? 'baked.'
+                    : result === pizza.PizzaBakeResult.CRISPY
+                      ? 'crispy.'
+                      : result === pizza.PizzaBakeResult.BURNT
+                        ? 'burnt.'
+                        : result === pizza.PizzaBakeResult.ON_FIRE
+                          ? 'on fire!'
+                          : 'unknown?');
+            } else {
+              console.log('result length incorrect');
+            }
+          });
+          pizzaBakeCharacteristic.subscribe(function (error) {
+            if (error) {
+              console.error(error);
+              return;
+            }
+
+            //
+            // Bake at 450 degrees!
+            //
+            const temperature = Buffer.alloc(2);
+            temperature.writeUInt16BE(450, 0);
+            pizzaBakeCharacteristic.write(temperature, false, function (err) {
+              if (err) {
+                console.log('bake error');
+              }
+            });
+          });
+        } else {
+          console.log('toppings error');
+        }
+      });
+    } else {
+      console.log('crust error');
+    }
+  });
+}
+
+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 () {
+  console.log('Caught interrupt signal');
+  noble.stopScanning(() => process.exit());
+});

package/examples/pizza/pizza.js

@@ -0,0 +1,60 @@
+const util = require('util');
+const events = require('events');
+
+const PizzaCrust = {
+  NORMAL: 0,
+  DEEP_DISH: 1,
+  THIN: 2
+};
+
+const PizzaToppings = {
+  NONE: 0,
+  PEPPERONI: 1 << 0,
+  MUSHROOMS: 1 << 1,
+  EXTRA_CHEESE: 1 << 2,
+  BLACK_OLIVES: 1 << 3,
+  CANADIAN_BACON: 1 << 4,
+  PINEAPPLE: 1 << 5,
+  BELL_PEPPERS: 1 << 6,
+  SAUSAGE: 1 << 7
+};
+
+const PizzaBakeResult = {
+  HALF_BAKED: 0,
+  BAKED: 1,
+  CRISPY: 2,
+  BURNT: 3,
+  ON_FIRE: 4
+};
+
+function Pizza () {
+  events.EventEmitter.call(this);
+  this.toppings = PizzaToppings.NONE;
+  this.crust = PizzaCrust.NORMAL;
+}
+
+util.inherits(Pizza, events.EventEmitter);
+
+Pizza.prototype.bake = function (temperature) {
+  const time = temperature * 10;
+  const self = this;
+  console.log('baking pizza at', temperature, 'degrees for', time, 'milliseconds');
+  setTimeout(function () {
+    const result =
+      (temperature < 350)
+        ? PizzaBakeResult.HALF_BAKED
+        : (temperature < 450)
+            ? PizzaBakeResult.BAKED
+            : (temperature < 500)
+                ? PizzaBakeResult.CRISPY
+                : (temperature < 600)
+                    ? PizzaBakeResult.BURNT
+                    : PizzaBakeResult.ON_FIRE;
+    self.emit('ready', result);
+  }, time);
+};
+
+module.exports.Pizza = Pizza;
+module.exports.PizzaToppings = PizzaToppings;
+module.exports.PizzaCrust = PizzaCrust;
+module.exports.PizzaBakeResult = PizzaBakeResult;