0201020EFFFFFF1819F99CD17000000000000416372A5107161C2A00000E7E

# Node.js
let buf = Buffer.from('0201020EFFFFFF1819F99CD17000000000000416372A5107161C2A00000E7E', 'hex');
let heartrate = buf.readUInt8(22);
let temperature = buf.readUInt16BE(29) / 100

# Need NodeJS >= v8.0.0
# yarn add eventsource@1.0.7

/**
 * sample for scan BLE devices and parse data
 * use router local API in this example
 * to run the code, you should have a Cassia Router
 */
const EventSource = require('eventsource');
const qs = require('querystring');

/*
 * replace it with your router ip adderss
 * remember switching on local API in setting page
 */
const HOST = 'http://10.100.99.117';

/*
 * scan devices
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#scan-bluetooth-devices
 * Sever-Sent Event(SSE) is used in scan, connection-state and notify of Cassia RESTful API,
 * SSE spec: https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
 * API will send ':keep-alive' every 30 seconds in SSE connection for user to check if the connection is active or not.
 * User need to call Cassia RESTful API to reconnect SSE in case that the connection is termincated abnormally, such as keep-alive lost, socket error, network problem, etc.
 * Nodejs library 'eventsource' handle the SSE reconnection automatically. For other lanuages, the reconnection may needs to be handled by users application.
 */
function openScanSse() {
  const query = {
    /*
     * filter devices whose rssi is below -75, and name begins with 'Cassia',
     * there are many other filters, you can find them in document
     * use proper filters can significantly reduce traffic between Router and AC
     */
    filter_rssi: -75,
    filter_name: 'Cassia*',
    /*
     * use active scan, default is passive scan
     * active scan makes devices response with data packet which usually contains device's name
     */
    active: 1
  };
  const url = `${HOST}/gap/nodes?event=1&${qs.encode(query)}`;
  const sse = new EventSource(url);

  sse.on('error', function(error) {
    console.error('open scan sse failed:', error);
  });
  
  /*
   * if scan open successful, it will return like follow:
   * 5.2.1 Data Description
   */
   sse.on('message', function(message) {
    let data = JSON.parse(message.data);

    let adDataHex = data.adData;
    if (!adDataHex) return;
    
    // Parsing broadcast packet data
    let deviceMac = data.bdaddrs[0].bdaddr;    
    let buf = Buffer.from(adDataHex, 'hex');
    let heartrate = buf.readUInt8(22);
    let temperature = buf.readUInt16BE(29) / 100
    console.log({adDataHex, deviceMac, heartrate, temperature});
  });
}

(async () => {
  try {
    openScanSse();
  } catch(ex) {
    console.error('fail:', ex);
  }
})();

{ adDataHex: '0201020EFFFFFF1819F99CD17000000000000416372A5407161C2A00000E81',
  deviceMac: '72:A2:28:A8:68:68',
  heartrate: 84,
  temperature: 37.13 }
// ...

# Need NodeJS >= v8.0.0
# yarn add request

/**
 * connect BLE device, write handle value, disconnect device
 */
const request = require('request');

/*
 * replace it with your router ip adderss
 * remember switching on local API in setting page
 */
const HOST = 'http://10.100.99.117';

/*
 * replace it with your device mac adderss
 */
const DEVICE_MAC = '72:A2:28:A8:68:68';

/*
 * replace it with your device addr type
 */
const DEVICE_ADDR_TYPE = 'random';

/*
 * replace it with your msg
 */
const ALERT_MESSAGE = 'Hello, Cassia!';


const ALERT_SERVICE_UUID = '00002a46-0000-1000-8000-00805f9b34fb';

function req(options) {
  return new Promise((resolve, reject) => {
    request(options, function (error, response) {
      if (error) reject(error);
      else if (response.statusCode !== 200) reject(response.body);
      else resolve(response.body);
    });
  });
}

/*
 * connect one device
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#connectdisconnect-to-a-target-device
 */
function connect(deviceMac, addrType) {
  let options = {
    method: 'POST',
    url: `${HOST}/gap/nodes/${deviceMac}/connection`,
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({timeout: 5000, type: addrType})
  };
  return req(options);
}

/*
 * Read/Write the Value of a Specific Characteristic
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#readwrite-the-value-of-a-specific-characteristic
 */
function write(deviceMac, handle, value) {
  let options = {
    method: 'GET',
    url: `${HOST}/gatt/nodes/${deviceMac}/handle/${handle}/value/${value}`,
  };
  return req(options);
}

/*
 * Read/Write the Value of a Specific Characteristic
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#readwrite-the-value-of-a-specific-characteristic
 */
function discover(deviceMac) {
  let options = {
    method: 'GET',
    url: `${HOST}/gatt/nodes/${deviceMac}/services/characteristics/descriptors`,
  };
  return req(options);
}

function getAlertChar(services) {
  for (let index = 0; index < services.length; index++) {
    let service = services[index];
    let characteristics = service.characteristics;
    let alertCharacteristic = characteristics.find(c => c.uuid === ALERT_SERVICE_UUID);
    if (alertCharacteristic) {
      return alertCharacteristic;
    }
  }
  return null;
}

/*
 * disconnect one device
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#connectdisconnect-to-a-target-device
 */
function disconnect(deviceMac) {
  let options = {
    method: 'DELETE',
    url: `${HOST}/gap/nodes/${deviceMac}/connection`,
  };
  return req(options);
}

(async () => {
  try {
    await connect(DEVICE_MAC, DEVICE_ADDR_TYPE);
    console.log('connect device ok:', DEVICE_MAC);

    let servicesJson = await discover(DEVICE_MAC);
    console.log('discover services ok:', servicesJson);
    let services = JSON.parse(servicesJson);
    let alertChar = getAlertChar(services);

    if (alertChar) {
      console.log('found alert char:', JSON.stringify(alertChar));
      let msgHex = Buffer.from(ALERT_MESSAGE).toString('hex');
      msgHex = `0501${msgHex}`;
      await write(DEVICE_MAC, alertChar.handle, msgHex);
      console.log('write alert char ok:', alertChar.handle, msgHex);
    }
    
    await disconnect(DEVICE_MAC);
    console.log('disconnect device ok:', DEVICE_MAC);
  } catch(ex) {
    console.error('fail:', ex);
  }
})();

# Need NodeJS >= v8.0.0
# yarn add eventsource@1.0.7
# yarn add request

/**
 * connect BLE device, open notification, receive notification data
 */
const EventSource = require('eventsource');
const request = require('request');

/*
 * replace it with your router ip adderss
 * remember switching on local API in setting page
 */
const HOST = 'http://10.100.99.117';

/*
 * replace it with your device mac adderss
 */
const DEVICE_MAC = '72:A2:28:A8:68:68';

/*
 * replace it with your device addr type
 */
const DEVICE_ADDR_TYPE = 'random';

const HEART_RATE_UUID = '00002a37-0000-1000-8000-00805f9b34fb';

function req(options) {
  return new Promise((resolve, reject) => {
    request(options, function (error, response) {
      if (error) reject(error);
      else if (response.statusCode !== 200) reject(response.body);
      else resolve(response.body);
    });
  });
}

/*
 * Receive Notification and Indication
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#receive-notification-and-indication
 * Sever-Sent Event(SSE) is used in scan, connection-state and notify of Cassia RESTful API,
 * SSE spec: https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
 * API will send ':keep-alive' every 30 seconds in SSE connection for user to check if the connection is active or not.
 * User need to call Cassia RESTful API to reconnect SSE in case that the connection is termincated abnormally, such as keep-alive lost, socket error, network problem, etc.
 * Nodejs library 'eventsource' handle the SSE reconnection automatically. For other lanuages, the reconnection may needs to be handled by users application.
 */
function openNotifySse() {
  const url = `${HOST}/gatt/nodes`;
  const sse = new EventSource(url);

  sse.on('error', error => {
    console.error('open notify sse failed:', error);
  });
  
  sse.on('message', message => {
    console.log('recevied notify sse message:', message);
    let data = JSON.parse(message.data);
    
    let deviceMac = data.id;
    let valueHex = data.value;
    let valueBuf = Buffer.from(valueHex, 'hex');
    let heartrate = valueBuf.readUInt8(1);
    console.log("heart rate: ", deviceMac, heartrate);
  });
  
  return Promise.resolve(sse);
}

/*
 * connect one device
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#connectdisconnect-to-a-target-device
 */
function connect(deviceMac, addrType) {
  let options = {
    method: 'POST',
    url: `${HOST}/gap/nodes/${deviceMac}/connection`,
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({timeout: 5000, type: addrType, fail_retry_times: 2})
  };
  return req(options);
}

/*
 * Read/Write the Value of a Specific Characteristic
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#readwrite-the-value-of-a-specific-characteristic
 */
function write(deviceMac, handle, value) {
  let options = {
    method: 'GET',
    url: `${HOST}/gatt/nodes/${deviceMac}/handle/${handle}/value/${value}`,
  };
  return req(options);
}

/*
 * Read/Write the Value of a Specific Characteristic
 * refer: /~https://github.com/CassiaNetworks/CassiaSDKGuide/wiki/RESTful-API#readwrite-the-value-of-a-specific-characteristic
 */
function discover(deviceMac) {
  let options = {
    method: 'GET',
    url: `${HOST}/gatt/nodes/${deviceMac}/services/characteristics/descriptors`,
  };
  return req(options);
}

function getHandleByUuid(services, uuid, isCCCD=false) {
  for (let index = 0; index < services.length; index++) {
    let service = services[index];
    let characteristics = service.characteristics;
    let characteristic = characteristics.find(c => c.uuid === uuid);
    if (!characteristic) continue;
    if (!isCCCD) return characteristic.handle;
    let descriptors = characteristic.descriptors;
    let descriptor = descriptors.find(d => d.uuid.toLowerCase() === '00002902-0000-1000-8000-00805f9b34fb');
    if (!descriptor) continue;
    return descriptor.handle;
  }
  return 0;
}

(async () => {
  try {
    await openNotifySse();
    console.log('open notify sse ok');

    await connect(DEVICE_MAC, DEVICE_ADDR_TYPE);
    console.log('connect device ok:', DEVICE_MAC);

    let servicesJson = await discover(DEVICE_MAC);
    console.log('discover services ok:', servicesJson);
    let services = JSON.parse(servicesJson);
    let handle = getHandleByUuid(services, HEART_RATE_UUID, true);

    if (!handle) {
      console.log('no heart rate service found');
      await disconnect(DEVICE_MAC);
      console.log('disconnect device ok:', DEVICE_MAC);
      return;
    }

    console.log('found uuid handle ok:', HEART_RATE_UUID, handle);
    let hex = '0100';
    await write(DEVICE_MAC, handle, hex);
    console.log('write alert char ok:', handle, hex);
  } catch(ex) {
    console.error('fail:', ex);
  }
})();