@stoprocent/noble 1.9.2-16

package/assets/noble-logo.svg

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="600px" height="266px" viewBox="0 0 600 266" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
+    <title>noble-logo-less-spacing3</title>
+    <description>Created with Sketch (http://www.bohemiancoding.com/sketch)</description>
+    <defs></defs>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" sketch:type="MSPage">
+        <g id="v2" sketch:type="MSLayerGroup" transform="translate(39.000000, 41.000000)">
+            <path d="M15.844,69.808 C16.169335,72.8986821 16.4133325,76.314648 16.576,80.056 C16.7386675,83.797352 16.82,86.8879878 16.82,89.328 L17.308,89.328 C20.5613496,82.6586333 25.8479634,77.2500207 33.168,73.102 C40.4880366,68.9539793 48.214626,66.88 56.348,66.88 C70.8254057,66.88 81.6832971,71.1906236 88.922,79.812 C96.1607029,88.4333764 99.78,99.8199292 99.78,113.972 L99.78,184 L83.188,184 L83.188,120.804 C83.188,114.785303 82.7000049,109.336024 81.724,104.456 C80.7479951,99.5759756 79.0806785,95.3873508 76.722,91.89 C74.3633215,88.3926492 71.1913533,85.6680098 67.206,83.716 C63.2206467,81.7639902 58.2186968,80.788 52.2,80.788 C47.807978,80.788 43.5380207,81.6826577 39.39,83.472 C35.2419793,85.2613423 31.5413496,87.9859817 28.288,91.646 C25.0346504,95.3060183 22.4320098,99.9419719 20.48,105.554 C18.5279902,111.166028 17.552,117.794628 17.552,125.44 L17.552,184 L0.96,184 L0.96,94.94 C0.96,91.8493179 0.87866748,87.8640244 0.716,82.984 C0.55333252,78.1039756 0.30933496,73.7120195 -0.016,69.808 L15.844,69.808 Z M215.616,126.904 C215.616,120.559968 214.599344,114.582028 212.566,108.97 C210.532657,103.357972 207.645352,98.4780207 203.904,94.33 C200.162648,90.1819793 195.608027,86.8880122 190.24,84.448 C184.871973,82.0079878 178.853367,80.788 172.184,80.788 C165.514633,80.788 159.536693,82.0079878 154.25,84.448 C148.963307,86.8880122 144.449352,90.1819793 140.708,94.33 C136.966648,98.4780207 134.079343,103.357972 132.046,108.97 C130.012656,114.582028 128.996,120.559968 128.996,126.904 C128.996,133.248032 130.012656,139.225972 132.046,144.838 C134.079343,150.450028 136.966648,155.329979 140.708,159.478 C144.449352,163.626021 148.963307,166.879322 154.25,169.238 C159.536693,171.596678 165.514633,172.776 172.184,172.776 C178.853367,172.776 184.871973,171.596678 190.24,169.238 C195.608027,166.879322 200.162648,163.626021 203.904,159.478 C207.645352,155.329979 210.532657,150.450028 212.566,144.838 C214.599344,139.225972 215.616,133.248032 215.616,126.904 Z M262.888,164.724 L262.888,184 L246.296,184 L246.296,-0.464 L262.888,-0.464 L262.888,89.572 L263.376,89.572 C268.256024,82.0892959 274.599961,76.4366858 282.408,72.614 C290.216039,68.7913142 298.267959,66.88 306.564,66.88 C315.510711,66.88 323.603297,68.4253179 330.842,71.516 C338.080703,74.6066821 344.261974,78.8359732 349.386,84.204 C354.510026,89.5720268 358.495319,95.9159634 361.342,103.236 C364.188681,110.556037 365.612,118.445291 365.612,126.904 C365.612,135.362709 364.188681,143.251963 361.342,150.572 C358.495319,157.892037 354.510026,164.235973 349.386,169.604 C344.261974,174.972027 338.080703,179.201318 330.842,182.292 C323.603297,185.382682 315.510711,186.928 306.564,186.928 C298.267959,186.928 290.216039,185.057352 282.408,181.316 C274.599961,177.574648 268.256024,172.044037 263.376,164.724 L262.888,164.724 Z M348.044,126.904 C348.044,120.559968 347.06801,114.582028 345.116,108.97 C343.16399,103.357972 340.358018,98.4780207 336.698,94.33 C333.037982,90.1819793 328.524027,86.8880122 323.156,84.448 C317.787973,82.0079878 311.688034,80.788 304.856,80.788 C298.511968,80.788 292.656027,81.9673215 287.288,84.326 C281.919973,86.6846785 277.28402,89.9379793 273.38,94.086 C269.47598,98.2340207 266.426011,103.113972 264.23,108.726 C262.033989,114.338028 260.936,120.397301 260.936,126.904 C260.936,133.410699 262.033989,139.469972 264.23,145.082 C266.426011,150.694028 269.47598,155.533313 273.38,159.6 C277.28402,163.666687 281.919973,166.879322 287.288,169.238 C292.656027,171.596678 298.511968,172.776 304.856,172.776 C311.688034,172.776 317.787973,171.596678 323.156,169.238 C328.524027,166.879322 333.037982,163.626021 336.698,159.478 C340.358018,155.329979 343.16399,150.450028 345.116,144.838 C347.06801,139.225972 348.044,133.248032 348.044,126.904 Z M395.316,184 L378.724,184 L378.724,-0.464 L395.316,-0.464 L395.316,184 Z M520.668,123.488 L520.668,127.148 C520.668,128.44934 520.586667,129.831993 520.424,131.296 L425.752,131.296 C425.914667,136.989362 427.053323,142.357308 429.168,147.4 C431.282677,152.442692 434.210648,156.834648 437.952,160.576 C441.693352,164.317352 446.085308,167.285989 451.128,169.482 C456.170692,171.678011 461.619971,172.776 467.476,172.776 C476.097376,172.776 483.539302,170.783353 489.802,166.798 C496.064698,162.812647 500.82265,158.217359 504.076,153.012 L516.52,162.772 C509.687966,171.393376 502.164708,177.574648 493.95,181.316 C485.735292,185.057352 476.910714,186.928 467.476,186.928 C459.017291,186.928 451.168703,185.423348 443.93,182.414 C436.691297,179.404652 430.469359,175.216027 425.264,169.848 C420.058641,164.479973 415.951348,158.136037 412.942,150.816 C409.932652,143.495963 408.428,135.525376 408.428,126.904 C408.428,118.282624 409.891985,110.312037 412.82,102.992 C415.748015,95.6719634 419.814641,89.3280268 425.02,83.96 C430.225359,78.5919732 436.325298,74.4033484 443.32,71.394 C450.314702,68.3846516 457.878626,66.88 466.012,66.88 C474.958711,66.88 482.847966,68.3846516 489.68,71.394 C496.512034,74.4033484 502.205311,78.4699744 506.76,83.594 C511.314689,88.7180256 514.771322,94.6959658 517.13,101.528 C519.488678,108.360034 520.668,115.679961 520.668,123.488 Z M503.832,118.12 C503.343998,107.383946 499.887365,98.4780354 493.462,91.402 C487.036635,84.3259646 477.886726,80.788 466.012,80.788 C460.481306,80.788 455.357357,81.8046565 450.64,83.838 C445.922643,85.8713435 441.774685,88.6366492 438.196,92.134 C434.617315,95.6313508 431.770677,99.6166443 429.656,104.09 C427.541323,108.563356 426.321335,113.239976 425.996,118.12 L503.832,118.12 Z" id="noble" fill="#1977E0" sketch:type="MSShapeGroup"></path>
+            <path d="M233.184,126.904 C233.184,135.525376 231.679348,143.495963 228.67,150.816 C225.660652,158.136037 221.472027,164.479973 216.104,169.848 C210.735973,175.216027 204.310704,179.404652 196.828,182.414 C189.345296,185.423348 181.130711,186.928 172.184,186.928 C163.399956,186.928 155.266704,185.423348 147.784,182.414 C140.301296,179.404652 133.876027,175.216027 128.508,169.848 C123.139973,164.479973 118.951348,158.136037 115.942,150.816 C112.932652,143.495963 111.428,135.525376 111.428,126.904 C111.428,118.282624 112.932652,110.312037 115.942,102.992 C118.951348,95.6719634 123.139973,89.3280268 128.508,83.96 C133.876027,78.5919732 140.301296,74.4033484 147.784,71.394 C155.266704,68.3846516 163.399956,66.88 172.184,66.88 C181.130711,66.88 189.345296,68.3846516 196.828,71.394 C204.310704,74.4033484 210.735973,78.5919732 216.104,83.96 C221.472027,89.3280268 225.660652,95.6719634 228.67,102.992 C231.679348,110.312037 233.184,118.282624 233.184,126.904 L233.184,126.904 Z" id="Path" fill="#1977E0" sketch:type="MSShapeGroup"></path>
+            <path d="M191.265672,141.408876 L174.98806,125.550988 L190.776119,110.181035 C191.265672,109.6931 191.510448,109.083181 191.510448,108.473262 C191.510448,107.863343 191.265672,107.131441 190.776119,106.765489 L173.274627,89.6877639 C172.540299,88.9558614 171.561194,88.8338776 170.58209,89.1998289 C169.725373,89.5657802 169.113433,90.4196664 169.113433,91.3955365 L169.113433,119.695767 L155.283582,106.277554 C154.304478,105.301684 152.713433,105.301684 151.856716,106.277554 C150.877612,107.253424 150.877612,108.839213 151.856716,109.6931 L168.01194,125.429004 L151.734328,141.164908 C150.755224,142.140778 150.755224,143.604583 151.734328,144.580453 C152.713433,145.556323 154.18209,145.556323 155.161194,144.580453 L168.991045,131.040256 L168.991045,160.560325 C168.991045,161.536195 169.602985,162.390081 170.459701,162.756032 C170.704478,162.878016 171.071642,163 171.438806,163 C172.050746,163 172.662687,162.756032 173.152239,162.268097 L191.143284,144.580453 C191.755224,144.336486 192,143.726567 192,143.116648 C192,142.506729 191.755224,141.774827 191.265672,141.408876 Z M174,97 L185,108.562162 L174,120 L174,97 L174,97 Z M174,155 L174,131 L186,143 L174,155 L174,155 Z" id="Shape" fill="#FFFFFF" sketch:type="MSShapeGroup"></path>
+        </g>
+    </g>
+</svg>

package/binding.gyp

@@ -0,0 +1,19 @@
+{
+  'targets': [
+    {
+      'target_name': 'noble',
+      'conditions': [
+        ['OS=="mac"', {
+          'dependencies': [
+            'lib/mac/binding.gyp:binding',
+          ],
+        }],
+        ['OS=="win"', {
+          'dependencies': [
+            'lib/win/binding.gyp:binding',
+          ],
+        }],
+      ],
+    },
+  ],
+}

package/codecov.yml

@@ -0,0 +1,5 @@
+coverage:
+  status:
+    project:
+      server:
+        target: 90%

package/examples/advertisement-discovery.js

@@ -0,0 +1,65 @@
+const noble = require('../index')({ extended: false });
+
+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}`);
+  console.log(
+    '\tcan I interest you in any of the following advertised services:'
+  );
+  console.log(`\t\t${JSON.stringify(peripheral.advertisement.serviceUuids)}`);
+  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')
+        )}`
+      );
+    }
+  }
+
+  if (peripheral.advertisement.manufacturerData) {
+    console.log('\there is my manufacturer data:');
+    console.log(
+      `\t\t${JSON.stringify(
+        peripheral.advertisement.manufacturerData.toString('hex')
+      )}`
+    );
+  }
+
+  if (peripheral.advertisement.txPowerLevel !== undefined) {
+    console.log('\tmy TX power level is:');
+    console.log(`\t\t${peripheral.advertisement.txPowerLevel}`);
+  }
+
+  console.log();
+});
+
+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/cache-gatt-discovery.js

@@ -0,0 +1,198 @@
+/* eslint-disable handle-callback-err */
+/** discover a device (here, the first one where the name was resolved),
+ * for the first device discover all services and characteristics,
+ * store the collected GATT information into a meta-data object and write to disk.
+ * Finds a temperature characteristic and registers for data.
+ * Prints timing information from discovered to connected to reading states.
+ */
+
+const noble = require('../index')({ extended: false });
+const fs = require('fs');
+
+// the sensor value to scan for, number of bits and factor for displaying it
+const CHANNEL = process.env.CHANNEL ? process.env.CHANNEL : 'Temperature';
+const BITS = process.env.BITS ? 1 * process.env.BITS : 16;
+const FACTOR = process.env.FACTOR ? 1.0 * process.env.FACTOR : 0.1;
+
+const EXT = '.dump';
+
+noble.on('stateChange', function (state) {
+  if (state === 'poweredOn') {
+    noble.startScanning([], false);
+  } else {
+    noble.stopScanning();
+  }
+});
+
+let tDisco = 0; // time when device was discovered
+let tConn = 0; // time when connection to device was established
+let tRead = 0; // time when reading data starts.
+
+// collect device meta-data into this object:
+const meta = {
+  services: [], // stores an array of GATT service data objects
+  characteristics: {} // a map with key service-UUID, stores the array of characteristics
+};
+
+noble.on('discover', function (peripheral) {
+  console.log(
+    `peripheral discovered (${peripheral.id} with address <${peripheral.address}, ${peripheral.addressType}>, connectable ${peripheral.connectable}, RSSI ${peripheral.rssi}:`
+  );
+  console.log('\thello my local name is:');
+  console.log(`\t\t${peripheral.advertisement.localName}`);
+  console.log();
+
+  // connect to the first device with a valid name
+  if (peripheral.advertisement.localName) {
+    console.log(
+      `Connecting to  ${peripheral.address} ${peripheral.advertisement.localName}`
+    );
+
+    tDisco = Date.now();
+
+    connectToDevice(peripheral);
+  }
+});
+
+const connectToDevice = function (peripheral) {
+  // BLE cannot scan and connect in parallel, so we stop scanning here:
+  noble.stopScanning();
+
+  peripheral.connect((error) => {
+    // noble.startScanning([], true)
+    if (error) {
+      console.log(`Connect error: ${error}`);
+      noble.startScanning([], true);
+      return;
+    }
+    tConn = Date.now();
+    console.log('Connected!');
+
+    findServices(noble, peripheral);
+  });
+};
+
+let servicesToRead = 0;
+
+const findServices = function (noble, peripheral) {
+  meta.uuid = peripheral.uuid;
+  meta.address = peripheral.address;
+  meta.name = peripheral.advertisement.localName; // not needed but nice to have
+
+  meta.characteristics = {};
+
+  // callback triggers with GATT-relevant data
+  peripheral.on('servicesDiscovered', (peripheral, services) => {
+    console.log(`servicesDiscovered: Found ${services.length} services! `);
+    meta.services = services;
+    for (const i in services) {
+      const service = services[i];
+      console.log(`\tservice ${i} : ${JSON.stringify(service)}`);
+      // meta.services[ service.uuid ] = service
+    }
+  });
+
+  peripheral.discoverServices([], (error, services) => {
+    if (error) {
+      console.error(error);
+      return;
+    }
+
+    let sensorCharacteristic;
+
+    servicesToRead = services.length;
+    // we found the list of services, now trigger characteristics lookup for each of them:
+
+    for (let i = 0; i < services.length; i++) {
+      const service = services[i];
+
+      service.on('characteristicsDiscovered', (characteristics) => {
+        // store the list of characteristics per service
+        meta.characteristics[service.uuid] = characteristics;
+
+        console.log(`SRV\t${service.uuid} characteristic GATT data: `);
+        for (let i = 0; i < characteristics.length; i++) {
+          console.log(
+            `\t${service.uuid} chara.\t  ${i} ${JSON.stringify(
+              characteristics[i]
+            )}`
+          );
+        }
+      });
+
+      service.discoverCharacteristics([], function (error, characteristics) {
+        if (error) {
+          console.error(error);
+          return;
+        }
+
+        console.log(`SRV\t${service.uuid} characteristic decoded data: `);
+        for (let j = 0; j < characteristics.length; j++) {
+          const ch = characteristics[j];
+          console.log(`\t${service.uuid} chara.\t  ${j} ${ch}`);
+
+          if (ch.name === CHANNEL) {
+            console.log(`found ${CHANNEL} characteristic!`);
+            sensorCharacteristic = ch;
+          }
+        }
+
+        servicesToRead--;
+        if (!servicesToRead) {
+          console.log('----------------- FINISHED');
+          console.log(JSON.stringify(meta, null, 4));
+          // write to file
+          fs.writeFile(
+            meta.uuid + EXT,
+            JSON.stringify(meta, null, 2),
+            function (err) {
+              if (err) {
+                return console.log(err);
+              }
+              console.log('The data was saved to ', meta.uuid + EXT);
+            }
+          );
+
+          if (sensorCharacteristic) {
+            console.log('Listening for temperature data...');
+
+            tRead = Date.now();
+
+            sensorCharacteristic.on('data', (data) => {
+              if (BITS === 16) {
+                console.log(` new ${CHANNEL} ${data.readUInt16LE() * FACTOR}`);
+              } else if (BITS === 32) {
+                console.log(` new ${CHANNEL} ${data.readUInt32LE() * FACTOR}`);
+              } else {
+                console.log(` Cannot cope with BITS value ${BITS}`);
+              }
+            });
+            sensorCharacteristic.read();
+          }
+
+          console.log(
+            `Timespan from discovery to connected: ${tConn - tDisco} ms`
+          );
+          console.log(
+            `Timespan from connected to reading  : ${tRead - tConn} ms`
+          );
+        }
+      });
+    }
+  });
+};
+
+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/cache-gatt-reconnect.js

@@ -0,0 +1,164 @@
+/* eslint-disable handle-callback-err */
+/** reconnect to a device that has been discovered earlier on using cache-gatt-discovery:
+ * If a device is discovered and a dump file exists, load it and connect to it, re-initializing service
+ * and characteristic objects in the noble stack.
+ * Finds a temperature characteristic and registers for data.
+ * Prints timing information from discovered to connected to reading states.
+ */
+
+const noble = require('../index')({ extended: false });
+const fs = require('fs');
+
+// the sensor value to scan for, number of bits and factor for displaying it
+const CHANNEL = process.env.CHANNEL ? process.env.CHANNEL : 'Temperature';
+const BITS = process.env.BITS ? 1 * process.env.BITS : 16;
+const FACTOR = process.env.FACTOR ? 1.0 * process.env.FACTOR : 0.1;
+
+const EXT = '.dump';
+
+noble.on('stateChange', function (state) {
+  if (state === 'poweredOn') {
+    noble.startScanning([], false);
+  } else {
+    noble.stopScanning();
+  }
+});
+
+let tDisco = 0; // time when device was discovered
+let tConn = 0; // time when connection to device was established
+let tRead = 0; // time when reading data starts.
+
+// collect device meta-data into this object:
+let meta = {
+  services: {}, // a map indexted by service-UUID -> contains service data
+  characteristics: {} // an map with key service-UUID, stores the array of characteristics
+};
+
+noble.on('discover', function (peripheral) {
+  console.log(
+    `peripheral discovered (${peripheral.id} with address <${peripheral.address}, ${peripheral.addressType}>, connectable ${peripheral.connectable}, RSSI ${peripheral.rssi}:`
+  );
+  console.log('\thello my local name is:');
+  console.log(`\t\t${peripheral.advertisement.localName}`);
+  console.log();
+
+  // Check if a dump  exists in the current directory.
+  fs.access(peripheral.uuid + EXT, fs.constants.F_OK, (err) => {
+    if (!err) {
+      console.log(`found dump file for ${peripheral.uuid}`);
+
+      tDisco = Date.now();
+
+      quickConnect(peripheral);
+    }
+  });
+});
+
+const quickConnect = function (peripheral) {
+  // BLE cannot scan and connect in parallel, so we stop scanning here:
+  noble.stopScanning();
+
+  peripheral.connect((error) => {
+    if (error) {
+      console.log(`Connect error: ${error}`);
+      noble.startScanning([], true);
+      return;
+    }
+    tConn = Date.now();
+    console.log('Connected!');
+
+    // load stored data. This needs to be done when connected, as we need a handle at GATT level
+    meta = loadData(peripheral);
+
+    // initialize the service and charateristics objects in Noble; return a temperature characteristic, if found
+    const sensorCharacteristic = setData(peripheral, meta);
+
+    if (!sensorCharacteristic) {
+      console.log('Warning - no temperature characteristic found.');
+    } else {
+      console.log('Listening for temperature data...');
+
+      tRead = Date.now();
+
+      sensorCharacteristic.on('data', (data) => {
+        if (BITS === 16) {
+          console.log(` new ${CHANNEL} ${data.readUInt16LE() * FACTOR}`);
+        } else if (BITS === 32) {
+          console.log(` new ${CHANNEL} ${data.readUInt32LE() * FACTOR}`);
+        } else {
+          console.log(` Cannot cope with BITS value ${BITS}`);
+        }
+      });
+      sensorCharacteristic.read();
+
+      console.log(`Timespan from discovery to connected: ${tConn - tDisco} ms`);
+      console.log(`Timespan from connected to reading  : ${tRead - tConn} ms`);
+    }
+  });
+};
+
+const loadData = function (peripheral) {
+  const dump = fs.readFileSync(peripheral.uuid + EXT);
+  const data = JSON.parse(dump);
+
+  // verify data: console.log(JSON.stringify(data,null,2))
+  return data;
+};
+
+const setData = function (peripheral, meta) {
+  // first, create the service objects:
+  console.log('initializing services... ');
+
+  // addServices returns an array of initialized service objects
+  const services = noble.addServices(peripheral.uuid, meta.services);
+
+  console.log('initialized services: ');
+  for (const i in services) {
+    const service = services[i];
+    console.log(`\tservice ${i} ${service}`);
+  }
+  console.log();
+
+  let sensorCharacteristic;
+
+  console.log('initializing characteristics... ');
+  // now, for each service, set the characteristics:
+  for (const i in services) {
+    const service = services[i];
+    const charas = meta.characteristics[service.uuid];
+    console.log(`\tservice ${i} ${service} ${JSON.stringify(charas)}`);
+
+    const characteristics = noble.addCharacteristics(
+      peripheral.uuid,
+      service.uuid,
+      charas
+    );
+
+    for (const j in characteristics) {
+      const characteristic = characteristics[j];
+      console.log(
+        `\t\tcharac ${service.uuid} ${j} ${characteristic} ${characteristic.rawProps}`
+      );
+      if (characteristic.name === CHANNEL) {
+        console.log(`\t\t\t-->found ${CHANNEL} characteristic!`);
+        sensorCharacteristic = characteristic;
+      }
+    }
+  }
+  return sensorCharacteristic;
+};
+
+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/echo.js

@@ -0,0 +1,104 @@
+/* eslint-disable handle-callback-err */
+// Connect to a peripheral running the echo service
+// https://github.com/noble/bleno/blob/master/examples/echo
+
+// subscribe to be notified when the value changes
+// start an interval to write data to the characteristic
+
+// const noble = require('noble');
+const noble = require('..')({ extended: false });
+
+const ECHO_SERVICE_UUID = 'ec00';
+const ECHO_CHARACTERISTIC_UUID = 'ec0e';
+
+noble.on('stateChange', (state) => {
+  if (state === 'poweredOn') {
+    console.log('Scanning');
+    noble.startScanning([ECHO_SERVICE_UUID], false);
+  } else {
+    noble.stopScanning();
+  }
+});
+
+noble.on('discover', (peripheral) => {
+  // connect to the first peripheral that is scanned
+  noble.stopScanning();
+  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;
+    }
+
+    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
+    );
+  });
+
+  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];
+
+  // data callback receives notifications
+  echoCharacteristic.on('data', (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 {
+      console.log('Subscribed for echoCharacteristic notifications');
+    }
+  });
+
+  // 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);
+}
+
+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/enter-exit.js

@@ -0,0 +1,78 @@
+/* eslint-disable handle-callback-err */
+/*
+  Continuously scans for peripherals and prints out message when they enter/exit
+
+    In range criteria:      RSSI < threshold
+    Out of range criteria:  lastSeen > grace period
+
+  based on code provided by: Mattias Ask (http://www.dittlof.com)
+*/
+const noble = require('../index')({ extended: false });
+
+const RSSI_THRESHOLD = -90;
+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: peripheral
+    };
+
+    console.log(
+      `"${peripheral.advertisement.localName}" entered (RSSI ${
+        peripheral.rssi
+      }) ${new Date()}`
+    );
+  }
+
+  inRange[id].lastSeen = Date.now();
+});
+
+setInterval(function () {
+  for (const id in inRange) {
+    if (inRange[id].lastSeen < Date.now() - EXIT_GRACE_PERIOD) {
+      const peripheral = inRange[id].peripheral;
+
+      console.log(
+        `"${peripheral.advertisement.localName}" exited (RSSI ${
+          peripheral.rssi
+        }) ${new Date()}`
+      );
+
+      delete inRange[id];
+    }
+  }
+}, 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 () {
+  console.log('Caught interrupt signal');
+  noble.stopScanning(() => process.exit());
+});