@stoprocent/bleno 0.7.0

package/examples/battery-service/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "battery-service",
+  "version": "0.1.1",
+  "description": "BLE (Bluetooth Low Energy) Battery Service",
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "author": {
+    "name": "Don Coleman",
+    "url": "https://github.com/don"
+  },
+  "dependencies": {
+    "@abandonware/bleno": "~0.5.1-3"
+  }
+}

package/examples/blink1/README.md

@@ -0,0 +1,44 @@
+bleno - [blink(1)](http://thingm.com/products/blink-1/) example
+===============================================
+This example allows you to control a [ThingM](http://thingm.com/) [blink(1)](http://thingm.com/products/blink-1/) via BLE.
+
+It uses bleno and [node-blink1](https://github.com/sandeepmistry/node-blink1) and requires a blink(1) to be connected via USB.
+
+See [main file](https://github.com/sandeepmistry/bleno/blob/master/examples/blink1/main.js) for entry point.
+
+[Device Information service](https://github.com/sandeepmistry/bleno/blob/master/examples/blink1/device-information-service.js)
+-----------------------------------
+
+UUID: [0x180A](https://developer.bluetooth.org/gatt/services/Pages/ServiceViewer.aspx?u=org.bluetooth.service.device_information.xml)
+
+__Characteristics:__
+
+ * [Serial Number](https://github.com/sandeepmistry/bleno/blob/master/examples/blink1/serial-number-characteristic.js)
+    * UUID: [0x2a25](https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.serial_number_string.xml)
+    * Properties: read
+    * Description: read the blink(1)'s serial number
+
+ * [Hardware Revision](https://github.com/sandeepmistry/bleno/blob/master/examples/blink1/hardware-revision-characteristic.js)
+    * UUID: [0x2a27](https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.hardware_revision_string.xml)
+    * Properties: read
+    * Description: read the blink(1)'s version   
+
+blink(1) service
+--------------------
+UUID: 0x01010101010101010101010101010101
+
+__Characteristics:__
+
+ * [RGB](https://github.com/sandeepmistry/bleno/blob/master/examples/blink1/blink1-rgb-characteristic.js)
+    * UUID: 01010101010101010101010101524742
+    * Properties: write, write without response
+    * Description: Set the blink(1)'s color
+        * Data format is: RRGGBB (3 bytes) - single byte for each color 
+        
+ * [Fade RGB](https://github.com/sandeepmistry/bleno/blob/master/examples/blink1/blink1-fade-rgb-characteristic.js)
+    * UUID: 01010101010101010166616465524742
+    *  Properties: write, write without response, notify
+    *  Description: Fade the blink(1)'s color and notication when fade is complete
+        * Data format is: TTTTRRGGBB (5 bytes)
+            * TTTT -  fade time in milliseconds (Little Endian)
+            * RRGGBB (3 bytes) - single byte for each color 

package/examples/blink1/blink1-fade-rgb-characteristic.js

@@ -0,0 +1,42 @@
+const bleno = require('../..');
+const BlenoCharacteristic = bleno.Characteristic;
+const BlenoDescriptor = bleno.Descriptor;
+
+class Blink1FaceRGBCharacteristic extends BlenoCharacteristic {
+  constructor (blink1) {
+    super({
+      uuid: '01010101010101010166616465524742',
+      properties: ['write', 'writeWithoutResponse', 'notify'],
+      descriptors: [
+        new BlenoDescriptor({
+          uuid: '2901',
+          value: 'fade blink(1) RGB value'
+        })
+      ]
+    });
+
+    this.blink1 = blink1;
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG);
+    } else if (data.length !== 5) {
+      callback(this.RESULT_INVALID_ATTRIBUTE_LENGTH);
+    } else {
+      const fadeMillis = data.readUInt16LE(0);
+      const r = data.readUInt8(2);
+      const g = data.readUInt8(3);
+      const b = data.readUInt8(4);
+
+      this.blink1.fadeToRGB(fadeMillis, r, g, b, () => {
+        if (this.updateValueCallback) {
+          this.updateValueCallback(Buffer.from([r, g, b]));
+        }
+        callback(this.RESULT_SUCCESS);
+      });
+    }
+  }
+}
+
+module.exports = Blink1FaceRGBCharacteristic;

package/examples/blink1/blink1-rgb-characteristic.js

@@ -0,0 +1,38 @@
+const bleno = require('../..');
+const BlenoCharacteristic = bleno.Characteristic;
+const BlenoDescriptor = bleno.Descriptor;
+
+class Blink1RGBCharacteristic extends BlenoCharacteristic {
+  constructor (blink1) {
+    super({
+      uuid: '01010101010101010101010101524742',
+      properties: ['write', 'writeWithoutResponse'],
+      descriptors: [
+        new BlenoDescriptor({
+          uuid: '2901',
+          value: 'set blink(1) RGB value'
+        })
+      ]
+    });
+
+    this.blink1 = blink1;
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG);
+    } else if (data.length !== 3) {
+      callback(this.RESULT_INVALID_ATTRIBUTE_LENGTH);
+    } else {
+      const r = data.readUInt8(0);
+      const g = data.readUInt8(1);
+      const b = data.readUInt8(2);
+
+      this.blink1.setRGB(r, g, b, () => {
+        callback(this.RESULT_SUCCESS);
+      });
+    }
+  }
+}
+
+module.exports = Blink1RGBCharacteristic;

package/examples/blink1/blink1-service.js

@@ -0,0 +1,19 @@
+const bleno = require('../..');
+const BlenoPrimaryService = bleno.PrimaryService;
+
+const Blink1RGBCharacteristic = require('./blink1-rgb-characteristic');
+const Blink1FadeRGBCharacteristic = require('./blink1-fade-rgb-characteristic');
+
+class Blink1Service extends BlenoPrimaryService {
+  constructor (blink1) {
+    super({
+      uuid: '01010101010101010101010101010101',
+      characteristics: [
+        new Blink1RGBCharacteristic(blink1),
+        new Blink1FadeRGBCharacteristic(blink1)
+      ]
+    });
+  }
+}
+
+module.exports = Blink1Service;

package/examples/blink1/device-information-service.js

@@ -0,0 +1,19 @@
+const bleno = require('../..');
+const BlenoPrimaryService = bleno.PrimaryService;
+
+const SerialNumberCharacteristic = require('./serial-number-characteristic');
+const HardwareRevisionCharacteristic = require('./hardware-revision-characteristic');
+
+class DeviceInformationService extends BlenoPrimaryService {
+  constructor (blink1) {
+    super({
+      uuid: '180a',
+      characteristics: [
+        new SerialNumberCharacteristic(blink1),
+        new HardwareRevisionCharacteristic(blink1)
+      ]
+    });
+  }
+}
+
+module.exports = DeviceInformationService;

package/examples/blink1/hardware-revision-characteristic.js

@@ -0,0 +1,32 @@
+const bleno = require('../..');
+const BlenoCharacteristic = bleno.Characteristic;
+const BlenoDescriptor = bleno.Descriptor;
+
+class HardwareRevisionCharacteristic extends BlenoCharacteristic {
+  constructor (blink1) {
+    super({
+      uuid: '2a27',
+      properties: ['read'],
+      descriptors: [
+        new BlenoDescriptor({
+          uuid: '2901',
+          value: 'blink(1) version'
+        })
+      ]
+    });
+
+    this.blink1 = blink1;
+  }
+
+  onReadRequest (offset, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG, null);
+    } else {
+      this.blink1.version((version) => {
+        callback(this.RESULT_SUCCESS, Buffer.from(version));
+      });
+    }
+  }
+}
+
+module.exports = HardwareRevisionCharacteristic;

package/examples/blink1/main.js

@@ -0,0 +1,32 @@
+const Blink1 = require('node-blink1');
+
+const bleno = require('../..');
+
+const DeviceInformationService = require('./device-information-service');
+const Blink1Service = require('./blink1-service');
+
+const blink1 = new Blink1();
+
+const deviceInformationService = new DeviceInformationService(blink1);
+const blink1Service = new Blink1Service(blink1);
+
+bleno.on('stateChange', function (state) {
+  console.log('on -> stateChange: ' + state);
+
+  if (state === 'poweredOn') {
+    bleno.startAdvertising('blink1', [blink1Service.uuid]);
+  } else {
+    bleno.stopAdvertising();
+  }
+});
+
+bleno.on('advertisingStart', function (error) {
+  console.log('on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));
+
+  if (!error) {
+    bleno.setServices([
+      deviceInformationService,
+      blink1Service
+    ]);
+  }
+});

package/examples/blink1/serial-number-characteristic.js

@@ -0,0 +1,21 @@
+const bleno = require('../..');
+const BlenoCharacteristic = bleno.Characteristic;
+const BlenoDescriptor = bleno.Descriptor;
+
+class SerialNumberCharacteristic extends BlenoCharacteristic {
+  constructor (blink1) {
+    super({
+      uuid: '2a25',
+      properties: ['read'],
+      value: Buffer.from(blink1.serialNumber),
+      descriptors: [
+        new BlenoDescriptor({
+          uuid: '2901',
+          value: 'blink(1) serial number'
+        })
+      ]
+    });
+  }
+}
+
+module.exports = SerialNumberCharacteristic;

package/examples/echo/characteristic.js

@@ -0,0 +1,45 @@
+const bleno = require('../..');
+
+const BlenoCharacteristic = bleno.Characteristic;
+
+class EchoCharacteristic extends BlenoCharacteristic {
+  constructor () {
+    super({
+      uuid: 'ec0e',
+      properties: ['read', 'write', 'notify'],
+      value: null
+    });
+
+    this._value = Buffer.alloc(0);
+    this._updateValueCallback = null;
+  }
+
+  onReadRequest (offset, callback) {
+    console.log('EchoCharacteristic - onReadRequest: value = ' + this._value.toString('hex'));
+    callback(this.RESULT_SUCCESS, this._value);
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    this._value = data;
+    console.log('EchoCharacteristic - onWriteRequest: value = ' + this._value.toString('hex'));
+
+    if (this._updateValueCallback) {
+      console.log('EchoCharacteristic - onWriteRequest: notifying');
+      this._updateValueCallback(this._value);
+    }
+
+    callback(this.RESULT_SUCCESS);
+  }
+
+  onSubscribe (maxValueSize, updateValueCallback) {
+    console.log('EchoCharacteristic - onSubscribe');
+    this._updateValueCallback = updateValueCallback;
+  }
+
+  onUnsubscribe () {
+    console.log('EchoCharacteristic - onUnsubscribe');
+    this._updateValueCallback = null;
+  }
+}
+
+module.exports = EchoCharacteristic;

package/examples/echo/main.js

@@ -0,0 +1,33 @@
+const bleno = require('../..');
+
+const BlenoPrimaryService = bleno.PrimaryService;
+
+const EchoCharacteristic = require('./characteristic');
+
+console.log('bleno - echo');
+
+bleno.on('stateChange', function (state) {
+  console.log('on -> stateChange: ' + state);
+
+  if (state === 'poweredOn') {
+    bleno.setAddress('11:22:44:55:99:10');
+    bleno.startAdvertising('echo', ['ec00']);
+  } else {
+    bleno.stopAdvertising();
+  }
+});
+
+bleno.on('advertisingStart', function (error) {
+  console.log('on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));
+
+  if (!error) {
+    bleno.setServices([
+      new BlenoPrimaryService({
+        uuid: 'ec00',
+        characteristics: [
+          new EchoCharacteristic()
+        ]
+      })
+    ]);
+  }
+});

package/examples/pizza/README.md

@@ -0,0 +1,16 @@
+# BLE Pizza Service
+
+This is an example program demonstrating BLE connectivity between a peripheral running bleno, and a central running noble.
+
+The service represents a robotic pizza oven, 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 peripheral example:
+
+    node peripheral
+
+And on another computer, connect as a central from [noble](https://github.com/sandeepmistry/noble/tree/master/examples/pizza).
+You can also use a [web app](http://strangesast.github.io/bleno-web-pizza-example) using [Web Bluetooth](https://developers.google.com/web/updates/2015/07/interact-with-ble-devices-on-the-web).

package/examples/pizza/peripheral.js

@@ -0,0 +1,57 @@
+//
+// Require bleno peripheral library.
+// https://github.com/sandeepmistry/bleno
+//
+const bleno = require('../..');
+
+//
+// Pizza
+// * has crust
+// * has toppings
+// * can be baked
+//
+const pizza = require('./pizza');
+
+//
+// The BLE Pizza Service!
+//
+const PizzaService = require('./pizza-service');
+
+//
+// A name to advertise our Pizza Service.
+//
+const name = 'PizzaSquat';
+const pizzaService = new PizzaService(new pizza.Pizza());
+
+//
+// Wait until the BLE radio powers on before attempting to advertise.
+// If you don't have a BLE radio, then it will never power on!
+//
+bleno.on('stateChange', function (state) {
+  if (state === 'poweredOn') {
+    //
+    // We will also advertise the service ID in the advertising packet,
+    // so it's easier to find.
+    //
+    bleno.startAdvertising(name, [pizzaService.uuid], function (err) {
+      if (err) {
+        console.log(err);
+      }
+    });
+  } else {
+    bleno.stopAdvertising();
+  }
+});
+
+bleno.on('advertisingStart', function (err) {
+  if (!err) {
+    console.log('advertising...');
+    //
+    // Once we are advertising, it's time to set up our services,
+    // along with our characteristics.
+    //
+    bleno.setServices([
+      pizzaService
+    ]);
+  }
+});

package/examples/pizza/pizza-bake-characteristic.js

@@ -0,0 +1,40 @@
+const bleno = require('../..');
+
+class PizzaBakeCharacteristic extends bleno.Characteristic {
+  constructor (pizza) {
+    super({
+      uuid: '13333333333333333333333333330003',
+      properties: ['notify', 'write'],
+      descriptors: [
+        new bleno.Descriptor({
+          uuid: '2901',
+          value: 'Bakes the pizza and notifies when done baking.'
+        })
+      ]
+    });
+
+    this.pizza = pizza;
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG);
+    } else if (data.length !== 2) {
+      callback(this.RESULT_INVALID_ATTRIBUTE_LENGTH);
+    } else {
+      const temperature = data.readUInt16BE(0);
+      const self = this;
+      this.pizza.once('ready', function (result) {
+        if (self.updateValueCallback) {
+          const responseData = Buffer.alloc(1);
+          responseData.writeUInt8(result, 0);
+          self.updateValueCallback(responseData);
+        }
+      });
+      this.pizza.bake(temperature);
+      callback(this.RESULT_SUCCESS);
+    }
+  }
+}
+
+module.exports = PizzaBakeCharacteristic;

package/examples/pizza/pizza-crust-characteristic.js

@@ -0,0 +1,52 @@
+const bleno = require('../..');
+const { PizzaCrust } = require('./pizza');
+
+class PizzaCrustCharacteristic extends bleno.Characteristic {
+  constructor (pizza) {
+    super({
+      uuid: '13333333333333333333333333330001',
+      properties: ['read', 'write'],
+      descriptors: [
+        new bleno.Descriptor({
+          uuid: '2901',
+          value: 'Gets or sets the type of pizza crust.'
+        })
+      ]
+    });
+
+    this.pizza = pizza;
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG);
+    } else if (data.length !== 1) {
+      callback(this.RESULT_INVALID_ATTRIBUTE_LENGTH);
+    } else {
+      const crust = data.readUInt8(0);
+      switch (crust) {
+        case PizzaCrust.NORMAL:
+        case PizzaCrust.DEEP_DISH:
+        case PizzaCrust.THIN:
+          this.pizza.crust = crust;
+          callback(this.RESULT_SUCCESS);
+          break;
+        default:
+          callback(this.RESULT_UNLIKELY_ERROR);
+          break;
+      }
+    }
+  }
+
+  onReadRequest (offset, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG, null);
+    } else {
+      const data = Buffer.alloc(1);
+      data.writeUInt8(this.pizza.crust, 0);
+      callback(this.RESULT_SUCCESS, data);
+    }
+  }
+}
+
+module.exports = PizzaCrustCharacteristic;

package/examples/pizza/pizza-service.js

@@ -0,0 +1,20 @@
+const bleno = require('../..');
+
+const PizzaCrustCharacteristic = require('./pizza-crust-characteristic');
+const PizzaToppingsCharacteristic = require('./pizza-toppings-characteristic');
+const PizzaBakeCharacteristic = require('./pizza-bake-characteristic');
+
+class PizzaService extends bleno.PrimaryService {
+  constructor (pizza) {
+    super({
+      uuid: '13333333333333333333333333333337',
+      characteristics: [
+        new PizzaCrustCharacteristic(pizza),
+        new PizzaToppingsCharacteristic(pizza),
+        new PizzaBakeCharacteristic(pizza)
+      ]
+    });
+  }
+}
+
+module.exports = PizzaService;

package/examples/pizza/pizza-toppings-characteristic.js

@@ -0,0 +1,41 @@
+const bleno = require('../..');
+
+class PizzaToppingsCharacteristic extends bleno.Characteristic {
+  constructor (pizza) {
+    super({
+      uuid: '13333333333333333333333333330002',
+      properties: ['read', 'write'],
+      descriptors: [
+        new bleno.Descriptor({
+          uuid: '2901',
+          value: 'Gets or sets the pizza toppings.'
+        })
+      ]
+    });
+
+    this.pizza = pizza;
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG);
+    } else if (data.length !== 2) {
+      callback(this.RESULT_INVALID_ATTRIBUTE_LENGTH);
+    } else {
+      this.pizza.toppings = data.readUInt16BE(0);
+      callback(this.RESULT_SUCCESS);
+    }
+  }
+
+  onReadRequest (offset, callback) {
+    if (offset) {
+      callback(this.RESULT_ATTR_NOT_LONG, null);
+    } else {
+      const data = Buffer.alloc(2);
+      data.writeUInt16BE(this.pizza.toppings, 0);
+      callback(this.RESULT_SUCCESS, data);
+    }
+  }
+}
+
+module.exports = PizzaToppingsCharacteristic;

package/examples/pizza/pizza.js

@@ -0,0 +1,58 @@
+const events = require('events');
+
+class Pizza extends events.EventEmitter {
+  constructor () {
+    super();
+    this.toppings = PizzaToppings.NONE;
+    this.crust = PizzaCrust.NORMAL;
+  }
+
+  bake (temperature) {
+    const time = temperature * 10;
+    console.log('baking pizza at', temperature, 'degrees for', time, 'milliseconds');
+    setTimeout(() => {
+      const result =
+        temperature < 350
+          ? PizzaBakeResult.HALF_BAKED
+          : temperature < 450
+            ? PizzaBakeResult.BAKED
+            : temperature < 500
+              ? PizzaBakeResult.CRISPY
+              : temperature < 600
+                ? PizzaBakeResult.BURNT
+                : PizzaBakeResult.ON_FIRE;
+      this.emit('ready', result);
+    }, time);
+  }
+}
+
+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 PizzaCrust = {
+  NORMAL: 0,
+  DEEP_DISH: 1,
+  THIN: 2
+};
+
+const PizzaBakeResult = {
+  HALF_BAKED: 0,
+  BAKED: 1,
+  CRISPY: 2,
+  BURNT: 3,
+  ON_FIRE: 4
+};
+
+module.exports.Pizza = Pizza;
+module.exports.PizzaToppings = PizzaToppings;
+module.exports.PizzaCrust = PizzaCrust;
+module.exports.PizzaBakeResult = PizzaBakeResult;

package/examples/uart/main.js

@@ -0,0 +1,23 @@
+const bleno = require('../../with-custom-binding')({
+  bindParams: {
+    uart: {
+      port: '/dev/tty...',
+      baudRate: 1000000
+    }
+  }
+});
+
+bleno.on('stateChange', state => {
+  console.log('on -> stateChange: ' + state);
+
+  if (state === 'poweredOn') {
+    bleno.setAddress('11:22:33:44:55:66');
+    bleno.startAdvertisingIBeacon('a2744045-7004-4da9-8ed3-6d2d9a208c0a', 1234, 5678);
+  } else {
+    bleno.stopAdvertising();
+  }
+});
+
+bleno.on('advertisingStart', error => {
+  console.log('on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));
+});