scan_beacon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d78009f7808d20ac2554c8c370a00ecd36b75e2e
+  data.tar.gz: 1f1f238adbe3cfcc939f349e9e2c57636505b292
+SHA512:
+  metadata.gz: 146ee276d74af008154a018ce72b0f410df1a294a1cf1f6383466cc06bbc2a37fa90e84272ceb9db70d9085f0491af86493091c7fb80d857dc44c31ca25e3912
+  data.tar.gz: 9947d6aced47920d648f5f5390a1a693997bc24d2a3a35d04b9c1eb9d409b0b6b0797a2c1d948b21c2cac44e5f0b6975ca405e6e977e9ef6d80518c99a5f88ba

data/.gitignore

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Radius Networks
+
+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,35 @@
+# ScanBeacon gem
+
+A ruby gem that allows you to scan for beacon advertisements using a BlueGiga BLE112 device.
+
+# Example Usage
+
+## Install the gem
+```
+gem install scan_beacon
+```
+
+## Start a scan
+``` ruby
+require 'scan_beacon'
+scanner = ScanBeacon::BLE112Scanner.new
+scanner.scan do |beacons|
+  beacons.each do |beacon|
+    puts beacon.inspect
+  end
+end
+```
+
+## Set a specific scan cycle period
+``` ruby
+require 'scan_beacon'
+scanner = ScanBeacon::BLE112Scanner.new cycle_seconds: 2
+scanner.scan do |beacons|
+  beacons.each do |beacon|
+    puts beacon.inspect
+  end
+end
+```
+
+# Dependencies
+You must have a BLE112 device plugged in to a USB port.

data/Rakefile

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

data/lib/scan_beacon.rb

@@ -0,0 +1,7 @@
+require "scan_beacon/version"
+require "scan_beacon/beacon"
+require "scan_beacon/beacon_parser"
+require "scan_beacon/ble112_scanner"
+
+module ScanBeacon
+end

data/lib/scan_beacon/beacon.rb

@@ -0,0 +1,47 @@
+require 'set'
+
+module ScanBeacon
+  class Beacon
+
+    attr_accessor :mac, :ids, :power, :beacon_types
+
+    def initialize(opts={})
+      @ids = opts[:ids]
+      @power = opts[:power]
+      @beacon_types = Set.new [opts[:beacon_type]]
+      @rssis = []
+    end
+
+    def ==(obj)
+      obj.is_a?(Beacon) && obj.mac == @mac && obj.ids == @ids
+    end
+
+    def add_rssi(val)
+      @rssis << val
+    end
+
+    def add_type(val)
+      @beacon_types << val
+    end
+
+    def rssi
+      @rssis.inject(0) {|sum, el| sum += el} / @rssis.size.to_f
+    end
+
+    def uuid
+      "#{ids[0][0..7]}-#{ids[0][8..11]}-#{ids[0][12..15]}-#{ids[0][16..19]}-#{ids[0][20..-1]}".upcase
+    end
+
+    def major
+      ids[1]
+    end
+
+    def minor
+      ids[2]
+    end
+
+    def inspect
+      "<Beacon ids=#{@ids.join(",")} rssi=#{rssi}, scans=#{@rssis.size}, power=#{@power}, type=\"#{@beacon_types.to_a.join(",")}\">"
+    end
+  end
+end

data/lib/scan_beacon/beacon_parser.rb

@@ -0,0 +1,53 @@
+module ScanBeacon
+  class BeaconParser
+
+    attr_accessor :beacon_type
+
+    def initialize(beacon_type, layout)
+      @beacon_type = beacon_type
+      @layout = layout.split(",")
+      @matchers = @layout.find_all {|item| item[0] == "m"}.map {|matcher|
+        _, range_start, range_end, expected = matcher.split(/:|=|-/)
+        {start: range_start.to_i, end: range_end.to_i, expected: expected}
+      }
+      @ids = @layout.find_all {|item| item[0] == "i"}.map {|id|
+        _, range_start, range_end = id.split(/:|-/)
+        {start: range_start.to_i, end: range_end.to_i}
+      }
+      _, power_start, power_end = @layout.find {|item| item[0] == "p"}.split(/:|-/)
+      @power = {start: power_start.to_i, end: power_end.to_i}
+    end
+
+    def matches?(data)
+      @matchers.each do |matcher|
+        return false unless data[matcher[:start]..matcher[:end]].unpack("H*").join == matcher[:expected]
+      end
+      return true
+    end
+
+    def parse(data)
+      return nil if !matches?(data)
+      Beacon.new(ids: parse_ids(data), power: parse_power(data), beacon_type: @beacon_type)
+    end
+
+    def parse_ids(data)
+      @ids.map {|id|
+        if id[:end] - id[:start] == 1
+          # two bytes, so treat it as a short (big endian)
+          data[id[:start]..id[:end]].unpack('S>')[0]
+        else
+          # not two bytes, so treat it as a hex string
+          data[id[:start]..id[:end]].unpack('H*').join
+        end
+      }
+    end
+
+    def parse_power(data)
+      data[@power[:start]..@power[:end]].unpack('c')[0]
+    end
+
+    def inspect
+      "<BeaconParser type=\"#{@beacon_type}\", layout=\"#{@layout.join(",")}\">"
+    end
+  end
+end

data/lib/scan_beacon/ble112_scanner.rb

@@ -0,0 +1,122 @@
+require 'timeout'
+
+module ScanBeacon
+  class BLE112Scanner
+    SCAN_CMD = [0,1,6,2,2].pack('CCCCC')
+    SCAN_PARAMS = [0, 5, 6, 7, 200,200, 0].pack('CCCCS<S<C')
+    RESET_CMD = [0,1,9,0,0].pack('ccccc')
+    MANUFACTURER_AD = 0xFF
+
+    DEFAULT_LAYOUTS = {altbeacon: "m:2-3=beac,i:4-19,i:20-21,i:22-23,p:24-24,d:25-25"}
+
+    attr_reader :beacons
+
+    def initialize(opts = {})
+      @port = opts[:port] || Dir.glob("/dev/{cu.usbmodem,ttyACM}*")[0]
+      @cycle_seconds = opts[:cycle_seconds] || 1
+      @parsers = DEFAULT_LAYOUTS.map {|name, layout| BeaconParser.new name, layout }
+      @beacons = []
+    end
+
+    def add_parser(parser)
+      @parsers << parser
+    end
+
+    def scan
+      clear_the_buffer
+      open_port do |port|
+        send_scan_command(port)
+        cycle_end = Time.now + @cycle_seconds
+
+        while true do
+          byte = port.each_byte.next
+          append_to_buffer(byte)
+          if Time.now > cycle_end
+            yield @beacons
+            @beacons = []
+            cycle_end = Time.now + @cycle_seconds
+          end
+        end
+      end
+    end
+
+    def open_port
+      File.open(@port, 'r+b') do |port|
+        yield port
+      end
+    end
+
+    def append_to_buffer(byte)
+      if @buffer.size == 0 && (byte == 0x00 || byte == 0x80)
+        @buffer << byte
+        @packet_type = byte
+      elsif @buffer.size == 1
+        @buffer << byte
+        @payload_length = byte
+        @expected_size = 4 + (@packet_type & 0x07) + @payload_length
+      elsif @buffer.size > 1
+        @buffer << byte
+        check_for_beacon
+      end
+    end
+
+    def check_for_beacon
+      if @expected_size && @buffer.size >= @expected_size
+        packet_class =  @buffer[2]
+        packet_command =  @buffer[3]
+        payload = @buffer[4..-1].pack('C*')
+        if (@packet_type & 0x80 != 0x00) && (packet_class == 0x06) &&
+            (packet_command == 0x00) && @buffer[19] == MANUFACTURER_AD
+          data = payload[16..-1]
+          beacon = nil
+          if @parsers.detect {|parser| beacon = parser.parse(data) }
+            beacon.mac = parse_mac(payload)
+            add_beacon(beacon, parse_rssi(payload))
+          end
+        end
+        clear_the_buffer
+      end
+    end
+
+    def add_beacon(beacon, rssi)
+      if idx = @beacons.find_index(beacon)
+        @beacons[idx].add_type beacon.beacon_types.first
+        beacon = @beacons[idx]
+      else
+        @beacons << beacon
+      end
+      beacon.add_rssi(rssi)
+    end
+
+    def parse_mac(payload)
+      payload[2..7].unpack('H2 H2 H2 H2 H2 H2').join(":")
+    end
+
+    def parse_rssi(payload)
+      payload[0].unpack('c')[0]
+    end
+
+    def clear_the_buffer
+      @buffer = []
+      @expected_size = nil
+    end
+
+    def send_scan_command(port)
+      # disconnect any connections
+      port.write([0,1,3,0,0].pack('CCCCC'))
+      port.read(7)
+      # turn off adverts
+      port.write([0,2,6,1,0,0].pack('CCCCCC'))
+      port.read(6)
+      # stop previous scan
+      port.write([0,0,6,4].pack('CCCC'))
+      port.read(6)
+      # write new scan params
+      port.write(SCAN_PARAMS)
+      port.read(6)
+      # start new scan
+      port.write(SCAN_CMD)
+      port.read(6)
+    end
+  end
+end

data/lib/scan_beacon/version.rb

@@ -0,0 +1,3 @@
+module ScanBeacon
+  VERSION = "0.1.0"
+end

data/scan_beacon.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scan_beacon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scan_beacon"
+  spec.version       = ScanBeacon::VERSION
+  spec.authors       = ["Radius Networks"]
+  spec.email         = ["support@radiusnetworks.com"]
+
+  spec.summary       = %q{Provides Beacon scanning functionality}
+  spec.homepage      = "https://github.com/RadiusNetworks/scanbeacon-gem"
+  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,96 @@
+--- !ruby/object:Gem::Specification
+name: scan_beacon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Radius Networks
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-22 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"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/scan_beacon.rb
+- lib/scan_beacon/beacon.rb
+- lib/scan_beacon/beacon_parser.rb
+- lib/scan_beacon/ble112_scanner.rb
+- lib/scan_beacon/version.rb
+- scan_beacon.gemspec
+homepage: https://github.com/RadiusNetworks/scanbeacon-gem
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Provides Beacon scanning functionality
+test_files: []