radbeacon 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 25442163473a2a7ce504430cce4a4ecb803abbd2
+  data.tar.gz: 423b8b43f661d3927f48cab858bea9c6cf86272c
+SHA512:
+  metadata.gz: 9b4504f24ec9ae91fff3e6de568d9603ce377e3b25c26e5bd92f4aa45789c182d6149be3a69b84688e2515db76285b91183b27e15612a77d970ed66c66a5fbfb
+  data.tar.gz: e3be66fd90ef611358c15e6fd879d4b8caaa43e50887173e7bd18b5afb4585166ad161b2575b2123136ff5b9b72c900720b5998ce682b558146059d56f4e7282

data/.gitignore

@@ -0,0 +1,5 @@
+cprun.sh
+yell.rb
+yeller.rb
+.DS_Store
+pkg/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in radbeacon.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    radbeacon (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.1.0)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.9)
+  radbeacon!
+  rake (~> 10.0)
+  rspec (~> 3.2)

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+<img src="http://i.imgur.com/gI6paLj.jpg" style="float:left" height="200">
+
+# What's all this then?
+
+A ruby gem that provides RadBeacon scanning and configuring capabilities on a linux machine.  Currently the only supported beacon type is RadBeacon USB.  
+
+# Scanning
+
+The `Radbeacon::Scanner` class has a `scan` method that returns an array of configurable RadBeacons (in the form of `Radbeacon::Usb` objects).  The duration of a scan (default = 5 seconds) is an attribute that can be set during initialization.  
+
+```
+scanner = Radbeacon::Scanner.new(10)
+radbeacons = scanner.scan
+```
+
+There is also a `fetch` method that returns a `Radbeacon::Usb` object for a given MAC address.
+
+```
+radbeacon = scanner.fetch("11:22:33:44:55:66")
+```
+
+#### Scan Options
+
+An (optional) `options` hash is available as an attribute on the `Scanner` class.  Below are the following options that can be used:
+
+- `:filter_mac` - Specify an array of MAC addresses that the scanner will filter for when doing a scan
+
+  ```
+  options[:filter_mac] = ["11:22:33:44:55:66", "55:66:77:88:99:00"]
+  ```
+
+- `:enable_hcitool_duration` - Use the custom hcitool-duration binary that adds a duration option to the `hcitool lescan` command.  To use this you must copy the new hcitool binary over the standard one (located at `/usr/bin/hcitool` on the ZBOX for example).
+
+  ```
+  options[:enable_hcitool_duration] = true
+  ```
+
+#Configuring
+
+All identifiers and other parameters are attributes on the `Radbeacon::Usb` class:
+
+- `dev_name`
+- `uuid`
+- `major`
+- `minor`
+- `power`
+- `tx_power`
+- `adv_rate`
+- `beacon_type`
+
+To make a config change, simply assign one of these attributes to the desired value and call the `save()` method with the beacon's PIN (as a string).
+
+```
+radbeacon.save(pin)
+```
+
+For example:
+
+```
+radbeacon.dev_name = "Test Beacon"
+radbeacon.uuid = "2F234454-CF6D-4A0F-ADF2-F4911BA9ABCD"
+radbeacon.major = 1
+radbeacon.minor = 1
+radbeacon.power = -66
+radbeacon.tx_power = 3
+radbeacon.adv_rate = 10
+radbeacon.beacon_type = "dual"
+radbeacon.save('0000')
+```
+
+# Other Actions
+
+All other RadBeacon actions are available as well
+
+##### Change PIN
+```
+radbeacon.change_pin(new_pin, old_pin)
+```
+
+##### Factory Reset
+```
+radbeacon.factory_reset(pin)
+```
+
+##### Boot to DFU
+```
+radbeacon.boot_to_dfu(pin)
+```
+
+##### Lock
+```
+radbeacon.lock(pin)
+```
+
+# Dependencies
+
+BlueZ (Linux Bluetooth stack) is required to scan for and communicate with RadBeacons via Bluetooth.  Specifically, the `hcitool` and `gatttool` commands.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/radbeacon.rb

@@ -0,0 +1,9 @@
+require "radbeacon/version"
+require "radbeacon/le_scanner"
+require "radbeacon/bluetooth_le_device"
+require "radbeacon/utils"
+require "radbeacon/scanner"
+require "radbeacon/usb"
+module Radbeacon
+
+end

data/lib/radbeacon/bluetooth_le_device.rb

@@ -0,0 +1,135 @@
+require 'pty'
+require 'expect'
+
+module Radbeacon
+  class BluetoothLeDevice
+    attr_reader :mac_address, :name, :is_connectable, :characteristics, :values, :errors
+
+    TIMEOUT = 0.5
+
+    def initialize(mac_address, name)
+      @errors = []
+      @mac_address = mac_address
+      @name = name
+      @is_connectable = false
+      @characteristics = Array.new
+      @values = Hash.new
+    end
+
+    def display
+      puts "MAC Address: " + @mac_address + " Name: " + @name + " Can connect: " + @is_connectable.to_s
+    end
+
+    def fetch_characteristics
+      result = false
+      if self.can_connect?
+        @is_connectable = true
+        if self.discover_characteristics
+          if self.char_values
+            result = true
+          end
+        end
+      end
+      result
+    end
+
+    def can_connect?
+      @errors = []
+      result = false
+      cmd = "gatttool -b #{@mac_address} --interactive"
+      PTY.spawn(cmd) do |output, input, pid|
+        output.expect(/\[LE\]>/)
+        input.puts "connect"
+        if output.expect(/Connection successful/, TIMEOUT)
+          @is_connectable = true
+          result = true
+        else
+          @errors << "Connection failed"
+        end
+        input.puts "quit"
+      end
+      result
+    end
+
+    def characteristics_command
+      success = true
+      output = nil
+      rout, wout = IO.pipe
+      rerr, werr = IO.pipe
+      characteristics_command_str = "gatttool -b #{@mac_address} --characteristics"
+      pid = Process.spawn(characteristics_command_str, :out => wout, :err => werr)
+      begin
+        Timeout.timeout(5) do
+          Process.wait(pid)
+        end
+      rescue Timeout::Error
+        Process.kill('TERM', pid)
+        success = false
+      end
+      wout.close
+      werr.close
+      stdout = rout.readlines.join("")
+      stderr = rerr.readlines.join("")
+      rout.close
+      rerr.close
+      if success
+        output = [stdout, stderr].join("")
+      end
+      output
+    end
+
+    def discover_characteristics
+      @errors = []
+      result = false
+      output = characteristics_command
+      if output && output.strip != "Discover all characteristics failed: Internal application error: I/O"
+        @characteristics = []
+        output.each_line do |line|
+          result = line.scan(/^handle = (0x[a-f0-9]{4}), char properties = (0x[a-f0-9]{2}), char value handle = (0x[a-f0-9]{4}), uuid = ([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/)
+          if !result.empty?
+            characteristic = {"handle" => result[0][0], "properties" => result[0][1], "value_handle" => result[0][2], "uuid" => result[0][3]}
+            @characteristics << characteristic
+          end
+        end
+        result = true
+      else
+        @errors << "Discover characteristics failed"
+      end
+      result
+    end
+
+    def char_values
+      @errors = []
+      result = false
+      cmd = "gatttool -b #{@mac_address} --interactive"
+      if @characteristics != []
+        PTY.spawn(cmd) do |output, input, pid|
+          output.expect(/\[LE\]>/)
+          input.puts "connect"
+          if output.expect(/Connection successful/, TIMEOUT)
+            @characteristics.each do |char|
+              input.puts "char-read-hnd #{char['value_handle']}"
+              if output.expect(/Characteristic value\/descriptor: /, TIMEOUT)
+                if value = output.expect(/^[0-9a-f\s]+\n/, TIMEOUT)
+                  @values[char['value_handle']] = value.first.strip
+                end
+              end
+            end
+            result = true
+          else
+            @errors << "Fetch characteristic values failed"
+          end
+          input.puts "quit"
+        end
+      else
+        @errors << "No characteristics present"
+      end
+      result
+    end
+
+    private
+
+    attr_writer :mac_address, :name, :is_connectable, :characteristics, :values, :errors
+
+  end
+end

data/lib/radbeacon/le_scanner.rb

@@ -0,0 +1,65 @@
+module Radbeacon
+
+  class LeScanner
+    attr_accessor :duration, :options
+
+    def initialize(duration = 5)
+      @duration = duration
+      @options = {}
+    end
+
+    def scan_command
+      rout, wout = IO.pipe
+      scan_command_str = "sudo hcitool lescan"
+      pid = Process.spawn(scan_command_str, :out => wout)
+      begin
+        Timeout.timeout(@duration) do
+          Process.wait(pid)
+        end
+      rescue Timeout::Error
+        Process.kill('TERM', pid)
+      end
+      wout.close
+      scan_output = rout.readlines.join("")
+      rout.close
+      scan_output
+    end
+
+    def scan_command_duration
+      `sudo hcitool lescan --duration #{@duration}`
+    end
+
+    def passive_scan
+      devices = Array.new
+      if @options[:enable_hcitool_duration] == true
+        scan_output = self.scan_command_duration
+      else
+        scan_output = self.scan_command
+      end
+      scan_output.each_line do |line|
+        result = line.scan(/^([A-F0-9:]{15}[A-F0-9]{2}) (.*)$/)
+        if !result.empty?
+          mac_address = result[0][0]
+          name = result[0][1]
+          if !devices.find {|s| s.mac_address == mac_address}
+            filter_mac = @options[:filter_mac]
+            if !filter_mac or (filter_mac.include?(mac_address) if filter_mac.is_a?(Array))
+              device = BluetoothLeDevice.new(mac_address, name)
+              devices << device
+            end
+          end
+        end
+      end
+      devices
+    end
+
+    def scan
+      devices = self.passive_scan
+      devices.each do |dev|
+        dev.fetch_characteristics
+      end
+      devices
+    end
+
+  end
+end

data/lib/radbeacon/scanner.rb

@@ -0,0 +1,28 @@
+module Radbeacon
+  class Scanner < LeScanner
+
+    C_DEVICE_NAME = "0x0003"
+    RADBEACON_USB = "52 61 64 42 65 61 63 6f 6e 20 55 53 42"
+
+    def scan
+      devices = super
+      radbeacons = devices.map { |dev| radbeacon_check(dev) }
+      radbeacons.compact
+    end
+
+    def fetch(mac_address)
+      dev = BluetoothLeDevice.new(mac_address, nil)
+      radbeacon_check(dev) if dev.fetch_characteristics
+    end
+
+    def radbeacon_check(device)
+      radbeacon = nil
+      case device.values[C_DEVICE_NAME]
+      when RADBEACON_USB
+        radbeacon = Usb.create_if_valid(device)
+      end
+      radbeacon
+    end
+
+  end
+end

data/lib/radbeacon/usb.rb

@@ -0,0 +1,196 @@
+module Radbeacon
+  class Usb < BluetoothLeDevice
+    include Utils
+
+    ## Define GATT characteristic constants
+    # Generic Access Profile
+    C_DEVICE_NAME = "0x0003"
+    C_APPEARANCE  = "0x0006"
+    # Device Information
+    C_MANUFACTURER_NAME = "0x000a"
+    C_MODEL_NUMBER      = "0x000d"
+    C_SERIAL_STRING     = "0x0010"
+    C_FIRMWARE_STRING   = "0x0013"
+    # Configuration
+    GATT_DEV_MODEL     = "0x0017"
+    GATT_DEV_ID        = "0x001a"
+    GATT_DEV_NAME      = "0x001d"
+    GATT_UUID          = "0x0020"
+    GATT_MAJOR         = "0x0023"
+    GATT_MINOR         = "0x0026"
+    GATT_POWER         = "0x0029"
+    GATT_TXPOWER       = "0x002c"
+    GATT_INTERVAL      = "0x002f"
+    GATT_RESULT        = "0x0032"
+    GATT_NEW_PIN       = "0x0035"
+    GATT_ACTION        = "0x0038"
+    GATT_PIN           = "0x003b"
+    GATT_BCTYPE        = "0x003e"
+    GATT_FWVERSION     = "0x0041"
+    GATT_CONN_TIMEOUT  = "0x0044"
+    GATT_BEACON_SWITCH = "0x0047"
+
+    ## Define GATT action/result constants
+    # Actions
+    GATT_ACTION_DONOTHING        = "00000000"
+    GATT_ACTION_UPDATE_ADV       = "00000001"
+    GATT_ACTION_UPDATE_PIN       = "00000002"
+    GATT_ACTION_FACTORY_RESET    = "00000003"
+    GATT_ACTION_DFU              = "00000004"
+    GATT_ACTION_LOCK             = "00000005"
+    GATT_ACTION_CONNECTABLE_TIME = "00000006"
+    # Results
+    GATT_SUCCES      = "00000000"
+    GATT_INVALID_PIN = "00000001"
+    GATT_ERROR       = "00000002" #not used
+
+    ## Transmit power and advertisement frequency values
+    TRANSMIT_POWER_VALUES = {-23 => "00", -21 => "01", -18 => "03", -14 => "05",
+      -11 => "07", -7 => "09", -4 => "0b", 0 => "0d", 3 => "0f"}
+    DEFAULT_MEASURED_POWER_VALUES = [-94, -92, -90, -86, -84, -79, -74, -72, -66]
+    ADVERTISING_RATE_VALUES = {0 => "0000", 1 => "2006", 2 => "0003", 3 => "f501", 4 => "7001",
+      5 => "2001", 6 => "ea00", 7 => "c400", 8 => "a800", 9 => "9100", 10 => "8000"}
+    BEACON_TYPES = {"ibeacon" => "01", "altbeacon" => "02", "dual" => "03"}
+
+    ## Timeout length for GATT commands
+    TIMEOUT = 0.5
+
+    ## Valid UUID pattern
+    VALID_UUID = /^[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}$/
+
+    attr_reader :mac_address, :errors, :dev_model, :dev_id, :dev_version
+    attr_accessor :dev_name, :uuid, :major, :minor, :power, :tx_power, :adv_rate, :beacon_type
+
+    def self.create_if_valid(device)
+      # Check everything
+      required_attrs = [GATT_DEV_MODEL, GATT_DEV_ID, GATT_FWVERSION, GATT_DEV_NAME,
+        GATT_UUID, GATT_MAJOR, GATT_MINOR, GATT_POWER, GATT_TXPOWER, GATT_INTERVAL, GATT_BCTYPE]
+      if required_attrs.all? { |key| device.values[key] }
+        self.new(device)
+      end
+    end
+
+    def initialize(device)
+      @errors = []
+      @mac_address = device.mac_address
+      @dev_model = bytes_to_text(device.values[GATT_DEV_MODEL])
+      @dev_id =  bytes_to_text(device.values[GATT_DEV_ID])
+      @dev_version =  bytes_to_text(device.values[GATT_FWVERSION])
+      @dev_name =  bytes_to_text(device.values[GATT_DEV_NAME])
+      @uuid =  bytes_to_uuid(device.values[GATT_UUID])
+      @major =  bytes_to_major_minor(device.values[GATT_MAJOR])
+      @minor = bytes_to_major_minor(device.values[GATT_MINOR])
+      @power = bytes_to_power(device.values[GATT_POWER])
+      @tx_power = TRANSMIT_POWER_VALUES.key(device.values[GATT_TXPOWER])
+      @adv_rate = ADVERTISING_RATE_VALUES.key(device.values[GATT_INTERVAL].delete(' '))
+      @beacon_type = BEACON_TYPES.key(device.values[GATT_BCTYPE])
+    end
+
+    def valid?
+      @errors = []
+      @errors << "Invalid device name" unless @dev_name.length <= 20
+      @errors << "Invalid UUID" unless @uuid.match(VALID_UUID)
+      @errors << "Invalid major value" unless @major.to_i.between?(0, 65535)
+      @errors << "Invalid minor value" unless @minor.to_i.between?(0, 65535)
+      @errors << "Invalid measured power value" unless @power.to_i.between?(-127, -1)
+      @errors << "Invalid transmit power" unless TRANSMIT_POWER_VALUES.has_key?(@tx_power)
+      @errors << "Invalid advertising rate" unless ADVERTISING_RATE_VALUES.has_key?(@adv_rate)
+      @errors << "Invalid beacon type" unless BEACON_TYPES.has_key?(@beacon_type)
+      if @errors.empty?
+        true
+      else
+        false
+      end
+    end
+
+    def save(pin)
+      if self.valid?
+        update_params_commands = ["#{GATT_DEV_NAME} #{text_to_bytes(@dev_name)}",
+          "#{GATT_UUID} #{uuid_to_bytes(@uuid)}", "#{GATT_MAJOR} #{major_minor_to_bytes(@major)}",
+          "#{GATT_MINOR} #{major_minor_to_bytes(@minor)}", "#{GATT_POWER} #{power_to_bytes(@power)}",
+          "#{GATT_TXPOWER} #{TRANSMIT_POWER_VALUES[@tx_power]}", "#{GATT_INTERVAL} #{ADVERTISING_RATE_VALUES[@adv_rate]}",
+          "#{GATT_BCTYPE} #{BEACON_TYPES[@beacon_type]}", "#{GATT_ACTION} #{GATT_ACTION_UPDATE_ADV}", "#{GATT_PIN} #{pin_to_bytes(pin)}"]
+        con(update_params_commands)
+      else
+        false
+      end
+    end
+
+    def change_pin(new_pin, old_pin)
+      update_pin_commands = ["#{GATT_NEW_PIN} #{pin_to_bytes(new_pin)}", "#{GATT_ACTION} #{GATT_ACTION_UPDATE_PIN}",
+        "#{GATT_PIN} #{pin_to_bytes(old_pin)}"]
+      con(update_pin_commands)
+    end
+
+    def factory_reset(pin)
+      reset_commands = ["#{GATT_ACTION} #{GATT_ACTION_FACTORY_RESET}", "#{GATT_PIN} #{pin_to_bytes(pin)}"]
+      con(reset_commands) && defaults
+    end
+
+    def boot_to_dfu(pin)
+      dfu_commands = ["#{GATT_ACTION} #{GATT_ACTION_DFU}", "#{GATT_PIN} #{pin_to_bytes(pin)}"]
+      con(dfu_commands)
+    end
+
+    def lock(pin)
+      lock_commands = ["#{GATT_ACTION} #{GATT_ACTION_LOCK}", "#{GATT_PIN} #{pin_to_bytes(pin)}"]
+      con(lock_commands)
+    end
+
+    private
+    attr_writer :mac_address, :errors, :dev_model, :dev_id, :dev_version
+
+    def defaults
+      @dev_name = "RadBeacon USB"
+      @uuid = "2F234454-CF6D-4A0F-ADF2-F4911BA9FFA6"
+      @major = 1
+      @minor = 1
+      @power = -66
+      @tx_power = 3
+      @adv_rate = 10
+      @beacon_type = "dual"
+    end
+
+    def con(commands)
+      @errors = []
+      result = false
+      cmd = "gatttool -b #{@mac_address} --interactive"
+      PTY.spawn(cmd) do |output, input, pid|
+        output.expect(/\[LE\]>/)
+        input.puts "connect"
+        if output.expect(/Connection successful/, TIMEOUT)
+          commands.each do |cmd|
+            cmd = "char-write-req #{cmd}"
+            input.puts cmd
+            if output.expect(/Characteristic value was written successfully/, TIMEOUT)
+              result = true
+            else
+              @errors << "Action failed: #{cmd}"
+              result = false
+              break
+            end
+          end
+          if result
+            input.puts "char-read-hnd #{GATT_RESULT}"
+            if output.expect(/Characteristic value\/descriptor: 00 00 00 00/, TIMEOUT)
+              result = true
+            else
+              @errors << "Invalid PIN"
+              result = false
+            end
+          end
+        else
+          @errors << "Connection failed"
+        end
+        input.puts "quit"
+        _, status = Process.waitpid2(pid)
+        if !status.success?
+          result = false
+          @errors << "Process failed to exit properly"
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/radbeacon/utils.rb

@@ -0,0 +1,41 @@
+module Radbeacon
+  module Utils
+
+    def text_to_bytes(text)
+      text.unpack('H*')[0]
+    end
+
+    def bytes_to_text(bytes)
+      [bytes.delete(' ')].pack('H*').gsub(/\x00/,'')
+    end
+
+    def uuid_to_bytes(uuid)
+      uuid.gsub(/-/, '')
+    end
+
+    def bytes_to_uuid(bytes)
+      bytes.delete(' ').sub(/([a-fA-F0-9]{8})([a-fA-F0-9]{4})([a-fA-F0-9]{4})([a-fA-F0-9]{4})([a-fA-F0-9]{12})/, '\1-\2-\3-\4-\5').upcase
+    end
+
+    def major_minor_to_bytes(value)
+      sprintf("%04x", value.to_i)
+    end
+
+    def bytes_to_major_minor(bytes)
+      bytes.delete(' ').to_i(16)
+    end
+
+    def power_to_bytes(power)
+      sprintf("%x", power.to_i + 256)
+    end
+
+    def bytes_to_power(bytes)
+      bytes.to_i(16) - 256
+    end
+
+    def pin_to_bytes(pin)
+      pin.unpack('H*')[0]
+    end
+
+  end
+end

data/lib/radbeacon/version.rb

@@ -0,0 +1,3 @@
+module Radbeacon
+  VERSION = "0.1.1"
+end

data/radbeacon.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'radbeacon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "radbeacon"
+  spec.version       = Radbeacon::VERSION
+  spec.authors       = ["Radius Networks"]
+  spec.email         = ["support@radiusnetworks.com"]
+
+  spec.summary       = %q{Provides RadBeacon (BLE Proximity Beacon) scanning and configuring capabilities on a linux machine.}
+  spec.homepage      = "http://www.radiusnetworks.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: radbeacon
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Radius Networks
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: 
+email:
+- support@radiusnetworks.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/radbeacon.rb
+- lib/radbeacon/bluetooth_le_device.rb
+- lib/radbeacon/le_scanner.rb
+- lib/radbeacon/scanner.rb
+- lib/radbeacon/usb.rb
+- lib/radbeacon/utils.rb
+- lib/radbeacon/version.rb
+- radbeacon.gemspec
+homepage: http://www.radiusnetworks.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Provides RadBeacon (BLE Proximity Beacon) scanning and configuring capabilities
+  on a linux machine.
+test_files: []