sphero-pwn

# Bluetooth LE communication channel with a robot. class BleChannel # Creates a channel over a set of discovered Bluetooth LE characteristics. # # @param {Peripheral} peripheral # @param {Object<String, Object<String, Characteristic>>} characteristics # the Bluetooth LE characteristics that make up a communication channel constructor: (peripheral, characteristics) -> @sourceId = "ble://#{peripheral.address}" @_peripheral = peripheral @_characteristics = characteristics @_characteristics.robot.responses.addListener 'data', (data) => @onData data @_openPromise = null @_closePromise = null # @see {SerialChannel#open} open: -> @_openPromise ||= @_activate() # @see {SerialChannel#write} write: (data) => @open() .then => offset = 0 writeChunk = => if offset >= data.length return Promise.resolve true (new Promise (resolve, reject) => length = data.length - offset length = 20 if length > 20 chunk = data.slice offset, offset + length @_characteristics.robot.commands.write chunk, true, (error) => if error reject error else offset += length resolve true ).then => writeChunk() writeChunk() # @see {SerialChannel#close} close: -> @open() .then => @_closePromise ||= new Promise (resolve, reject) => @_peripheral.disconnect() resolve true # @see {SerialChannel#onData} onData: (data) -> return # @see {SerialChannel#onError} onError: (error) -> return # @see {SerialChannel#sourceId} sourceId: null # Performs the serial channel activation sequence. # # @return {Promise<Boolean>} resolved with true when the robot received the # commands needed to activate the serial channel _activate: -> chain = Promise.resolve true for write in BleChannel._activationSequence do (write) => name = write[0] buffer = write[1] chain = chain.then => BleChannel._bleWrite @_characteristics.radio[write[0]], write[1] chain.then => BleChannel._bleNotify @_characteristics.robot.responses # Connects to a robot over Bluetooth LE. # # @param {Peripheral} peripheral a Bluetooth LE peripheral that might be a # Sphero robot # @return {Promise<BleChannel?>} resolved with a {BleChannel} instance # connecting to the robot represented by the given peripheral; the instance # may be null if the peripheral is not a Sphero robot @fromPeripheral: (peripheral) -> @_bleConnect(peripheral) .then => @_bleGetServices(peripheral) .then (services) => if services is null peripheral.disconnect() return null @_bleGetCharacteristics peripheral, services .then (characteristics) => if characteristics is null peripheral.disconnect() return null new BleChannel peripheral, characteristics # Enables notifications coming in from a Bluetooth LE characteristic. # # @param {Characteristic} characteristic the Bluetooth LE characteristic # whose change notifications will be received # @return {Promise<Boolean>} resolved with true when the characteristic's # notifications are enabled @_bleNotify: (characteristic) -> new Promise (resolve, reject) -> characteristic.notify true, (error) -> if error reject error return resolve true # Writes to a Bluetooth LE characteristic. # # @param {Characteristic} characteristic the Bluetooth LE characteristic # @param {Buffer} data the data that will be written to the characteristic # @return {Promise<Boolean>} resolved with true when the characteristic is # written @_bleWrite: (characteristic, data) -> new Promise (resolve, reject) => characteristic.write data, true, (error) => if error reject error return resolve true # Connects to a Bluetooth LE peripheral. # # @param {Peripheral} peripheral a Bluetooth LE peripheral that might be a # Sphero robot # @return {Promise<Boolean>} resolved with true when the peripheral is # connected @_bleConnect: (peripheral) -> new Promise (resolve, reject) -> onBleConnect = -> peripheral.removeListener 'connect', onBleConnect resolve true peripheral.addListener 'connect', onBleConnect peripheral.connect() # Discovers the robot's Bluetooth LE services. # # @param {Peripheral} peripheral a Bluetooth LE peripheral that might be a # Sphero robot # @return {Promise<Boolean>} resolved with an object containing the robot's # services, indexed by type; null if the peripheral does not have all the # services of a Sphero robot @_bleGetServices: (peripheral) -> new Promise (resolve, reject) => uuidList = Object.getOwnPropertyNames @_serviceUuids peripheral.discoverServices uuidList, (error, list) => if error reject error peripheral.disconnect() return resolve @_extractBleObjects(@_serviceUuids, list) # Extracts Bluetooth LE objects by their UUIDs from a list of objects. # # @param {Object<String, String>} uuids maps the desired UUIDs to # developer-friendly object names # @param {Array<Object>} list the list that contains the desired Bluetooth # objects # @return {Object?} the desired Bluetooth LE objects, indexed by name; null # if the # list of services does not include all the robot's services @_extractBleObjects: (uuids, list) -> objects = {} for object in list if name = uuids[object.uuid] objects[name] = object for own uuid, name of uuids return null unless objects[name] objects # Discovers the characteristics of a robot's Bluetooth LE services. # # @param {Peripheral} periperheral the Bluetooth LE peripheral whose # characteristics are getting discovered # @param {Object<String, Service>} services maps developer-friendly service # names to the Bluetooth LE services whose characteristics shall be # discovered # @return {Promise<Object?<String, Object<String, Characteristic>>>} resolves # with a mapping from developer-friendly service and characteristic names # to Bluetooth LE characteristics; the mapping may be null if any of the # services is missing a characteristic @_bleGetCharacteristics: (peripheral, services) -> promiseList = for name, service of services @_bleGetServiceCharacteristics peripheral, name, service Promise.all(promiseList).then (resolutions) -> result = {} for resolution in resolutions name = resolution[0] characteristics = resolution[1] if characteristics is null return null result[name] = characteristics result # Discovers the characteristics of a Bluetooth LE service. # # @param {Peripheral} periperheral the Bluetooth LE peripheral whose # characteristics are getting discovered # @param {Service} service the service whose characteristics are getting # discovered # @param {String} developer-friendly name for the service whose # characteristics are getting discovered # @return {Promise<Array<String, Object<String, Characteristic>>} resolves # with a 2-element array; the first element is the service's # developer-friendly name, and the second element maps developer-friendly # characteristic names to Bluetooth LE characteristics; the second element # may be null if any of the desired characteristics is missing @_bleGetServiceCharacteristics: (peripheral, name, service) -> new Promise (resolve, reject) => uuids = @_characteristicUuids[name] uuidList = Object.getOwnPropertyNames uuids service.discoverCharacteristics uuidList, (error, list) => if error peripheral.disconnect() reject error return resolve [name, @_extractBleObjects(uuids, list)] # @return {Object<String, String>} UUIDs for Sphero BLE services @_serviceUuids: '22bb746f2ba075542d6f726568705327': 'robot' '22bb746f2bb075542d6f726568705327': 'radio' # @return {Object<String, String>} UUIDs for the interesting characteristics # of the radio service @_characteristicUuids: radio: '22bb746f2bb275542d6f726568705327': 'txPower' '22bb746f2bb775542d6f726568705327': 'deepSleep' '22bb746f2bbd75542d6f726568705327': 'antiDos' '22bb746f2bbe75542d6f726568705327': 'antiDosTimeout' '22bb746f2bbf75542d6f726568705327': 'wakeCpu' robot: '22bb746f2ba175542d6f726568705327': 'commands' '22bb746f2ba675542d6f726568705327': 'responses' # @return {Array<String, Buffer>} the sequence of data that must be written # to the robot's radio characteristics to activate its serial connection @_activationSequence: [ ['antiDos', new Buffer("011i3")], ['txPower', new Buffer("\x07")], ['wakeCpu', new Buffer("\x01")], ] module.exports = BleChannel