sb-ble 0.5.0

data/lib/ble/agent.rb

@@ -0,0 +1,46 @@
+module BLE
+class Agent < DBus::Object
+    @log = Logger.new($stdout)
+    # https://kernel.googlesource.com/pub/scm/bluetooth/bluez/+/refs/heads/master/doc/agent-api.txt
+    dbus_interface I_AGENT do
+        dbus_method :Release do
+            @log.debug "Release()"
+            exit false
+        end
+        
+        dbus_method :RequestPinCode, "in device:o, out ret:s" do |device|
+            @log.debug{ "RequestPinCode(#{device})" }
+            ["0000"]
+        end
+        
+        dbus_method :RequestPasskey, "in device:o, out ret:u" do |device|
+            @log.debug{ "RequestPasskey(#{device})" }
+            raise DBus.error("org.bluez.Error.Rejected")
+        end
+        
+        dbus_method :DisplayPasskey, "in device:o, in passkey:u, in entered:y" do |device, passkey, entered|
+            @log.debug{ "DisplayPasskey(#{device}, #{passkey}, #{entered})" }
+            raise DBus.error("org.bluez.Error.Rejected")
+        end
+        
+        dbus_method :RequestConfirmation, "in device:o, in passkey:u" do |device, passkey|
+            @log.debug{ "RequestConfirmation(#{device}, #{passkey})" }
+            raise DBus.error("org.bluez.Error.Rejected")
+        end
+        
+        dbus_method :Authorize, "in device:o, in uuid:s" do |device, uuid|
+            @log.debug{ "Authorize(#{device}, #{uuid})" }
+        end
+        
+        dbus_method :ConfirmModeChange, "in mode:s" do |mode|
+            @log.debug{ "ConfirmModeChange(#{mode})" }
+            raise DBus.error("org.bluez.Error.Rejected")
+        end
+        
+        dbus_method :Cancel do
+            @log.debug "Cancel()"
+            raise DBus.error("org.bluez.Error.Rejected")
+        end
+    end
+end
+end

data/lib/ble/char_desc.rb

@@ -0,0 +1,63 @@
+# Encapsulates Characteristic descriptors and offers easy
+# access to characteristic related information.
+#
+module BLE
+  class CharDesc
+    attr_reader :desc
+    # @param desc [Hash] Descriptors.
+    def initialize(desc)
+      @desc= desc
+    end
+    def flags
+      @flags||= @desc[:flags]
+    end
+    def config
+      @config||= Characteristic[@desc[:uuid]]
+    end
+
+    def uuid
+      @desc[:uuid]
+    end
+    def flag?(flag_name)
+      flags.include?(flag_name)
+    end
+
+    # Does outgoing values have processors configured?
+    # If yes, the value needs to be pre-processed before being send.
+    def write_processors?
+      verifier? or write_pre_processor?
+    end
+    # Does incoming values have processors configured?
+    # If yes, the value needs to be post-processed after being received.
+    def read_processors?
+      config && read_post_processor?
+    end
+    # It has been configured a verifier preprocessor to check
+    # outgoing data?
+    def verifier?
+      config[:vrfy]
+    end
+    def write_pre_processor?
+      config[:out]
+    end
+    def read_post_processor?
+      config[:in]
+    end
+    # Is the received value verified by the verifier?
+    def verifies?(val)
+      config[:vrfy].call(val)
+    end
+    def pre_process(val)
+      if verifier? && !verifies?(val)
+        raise ArgumentError,
+          "bad value for characteristic '#{uuid}'"
+      end
+      val = config[:out].call(val) if write_pre_processor?
+    end
+
+    def post_process(val)
+      val = config[:in].call(val) if read_post_processor?
+    end
+
+  end
+end

data/lib/ble/char_registry.rb

@@ -0,0 +1,142 @@
+# To add a new characteristic description:
+#   BLE::Characteristic.add 'c4935338-4307-47cf-ae1f-feac9e2b3ae7',
+#       name: 'Controlled mind',
+#       type: 'net.cortex-minus.characteristic.controlled_mind'
+#       vrfy: ->(x) { x >= 0 },
+#         in: ->(s) { s.unpack('s<').first },
+#        out: ->(v) { [ v ].pack('s<') }
+#
+# Returned characteristic description will be a hash:
+#   {
+#      name: "Bluetooth characteristic name",
+#      type: "org.bluetooth.characteristic.name",
+#      uuid: "128bit-uuid-string",
+#      vrfy: ->(x) { verify_value(x) },
+#        in: ->(s) { s.unpack(....) ... },
+#       out: ->(v) { [ v ].pack(....) ... }
+#   }
+#
+module BLE
+  module CharRegistry
+
+    private
+
+    DB_UUID     = {}
+    DB_TYPE     = {}
+    DB_NICKNAME = {}
+
+    public
+    def self.included(klass)
+      class << klass
+        # Get characteristic description from nickname.
+        #
+        # @param id [Symbol] nickname
+        # @return [CharDesc] characteristic description
+        def by_nickname(id)
+          DB_NICKNAME[id]
+        end
+
+        # Get characteristic description from uuid.
+        #
+        # @param id [String] uuid
+        # @return [CharDesc] characteristic description
+        def by_uuid(id)
+          DB_UUID[id]
+        end
+
+        # Get characteristic description from type
+        #
+        # @param id [Strig] type
+        # @return [CharDesc] characteristic description
+        def by_type(id)
+          DB_TYPE[id]
+        end
+
+        # Get a characteristic description from it's id
+        # @param id [Symbol,String]
+        # @return [CharDesc]
+        def [](id)
+          case id
+          when Symbol      then DB_NICKNAME[id]
+          when UUID::REGEX then DB_UUID[id]
+          when String      then DB_TYPE[id]
+          when Integer     then DB_UUID[BLE::UUID(id)]
+          else raise ArgumentError, "invalid type for characteristic id"
+          end
+        end
+
+
+        # Add a characteristic description.
+        # @example Add a characteristic description with a 16-bit uuid
+        #   module Characteristic
+        #       add 0x2A6E,
+        #           name: 'Temperature',
+        #           type: 'org.bluetooth.characteristic.temperature',
+        #           vrfy: ->(x) { (0..100).include?(x) },
+        #             in: ->(s) { s.unpack('s<').first.to_f / 100 },
+        #            out: ->(v) { [ v*100 ].pack('s<') }
+        #   end
+        #
+        # @example Add a characteristic description with a 128-bit uuid
+        #   module Characteristic
+        #       add 'c4935338-4307-47cf-ae1f-feac9e2b3ae7',
+        #           name: 'Controlled mind',
+        #           type: 'net.cortex-minus.characteristic.controlled_mind',
+        #           vrfy: ->(x) { x >= 0 },
+        #             in: ->(s) { s.unpack('s<').first },
+        #            out: ->(v) { [ v ].pack('s<') }
+        #   end
+        #
+        # @param uuid [Integer, String] 16-bit, 32-bit or 128-bit uuid
+        # @param name [String]
+        # @option opts :type [String] type
+        # @option opts :nick [Symbol] nickname
+        # @option opts :in   [Proc] convert to ruby
+        # @option opts :out  [Proc] convert to bluetooth data
+        # @option opts :vry  [Proc] verify
+        # @return [CharDesc] characteristic description
+        def add(uuid, name:, **opts)
+          uuid = BLE::UUID(uuid)
+          type =  opts.delete :type
+          nick = opts.delete :nick
+          _in  = opts.delete :in
+          _out = opts.delete :out
+          vrfy = opts.delete :vrfy
+          if opts.first
+            raise ArgumentError, "unknown keyword: #{opts.first[0]}"
+          end
+
+          char_config= DB_UUID[uuid] = {
+            uuid: uuid,
+            name: name,
+            in: _in,
+            out: _out,
+            vrfy: vrfy
+          }
+
+          # Add type if specified
+          if type
+            type = type.downcase
+            char_config.merge!(type: type)
+            DB_TYPE[type] = char_config
+          end
+
+          # Add nickname if specified or can be derived from type
+          if nick.nil? && type && type =~ /\.(?<key>[^.]+)$/
+            nick = $1.to_sym if type.start_with? 'org.bluetooth.characteristic'
+          end
+          if nick
+            if DB_NICKNAME.include?(nick)
+              raise ArgumentError,
+                "nickname '#{nick}' already registered (uuid: #{uuid})"
+            end
+            DB_NICKNAME[nick] = char_config
+          end
+        end
+
+
+      end
+    end
+
+  end
+end

data/lib/ble/characteristic.rb

@@ -0,0 +1,85 @@
+require 'forwardable'
+module BLE
+  # Build information about {https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicsHome.aspx Bluetooth Characteristics}
+  #
+  class Characteristic
+    include CharRegistry
+    extend Forwardable
+
+    # Notify of characteristic not found
+    class NotFound < BLE::NotFound
+    end
+
+    def initialize(desc)
+      @dbus_obj= desc[:obj]
+      @desc= CharDesc.new(desc)
+    end
+
+    def_delegators :@desc, :flag?, :uuid
+
+    private
+    FLAGS    = [ 'broadcast',
+      'read',
+      'write-without-response',
+      'write',
+      'notify',
+      'indicate',
+      'authenticated-signed-writes',
+      'reliable-write',
+      'writable-auxiliaries',
+      'encrypt-read',
+      'encrypt-write',
+      'encrypt-authenticated-read',
+      'encrypt-authenticated-write' ]
+
+
+    #++++++++++++++++++++++++++++
+    public
+    #++++++++++++++++++++++++++++
+
+    def write(val, raw: false)
+      val= _serialize_value(val, raw: raw)
+      @dbus_obj[I_GATT_CHARACTERISTIC].WriteValue(val)
+    end
+
+    def read(raw: false)
+      val= @dbus_obj[I_GATT_CHARACTERISTIC].ReadValue().first
+      val= _deserialize_value(val, raw: raw)
+    end
+
+    # Register to this characteristic for notifications when
+    # its value changes.
+    def notify!
+      @dbus_obj[I_GATT_CHARACTERISTIC].StartNotify
+    end
+
+    def on_change(raw: false, &callback)
+      @dbus_obj[I_PROPERTIES].on_signal('PropertiesChanged') do |intf, props|
+        case intf
+        when I_GATT_CHARACTERISTIC
+          val= _deserialize_value(props['Value'], raw: raw)
+          callback.call(val)
+        end
+      end
+    end
+    #----------------------------
+    private
+    #----------------------------
+
+    # Convert Arrays of bytes returned by DBus to Strings of bytes.
+    def _serialize_value(val, raw: false)
+      if !raw && @desc.write_processors?
+        val= @desc.pre_process(val)
+      end
+      val.unpack('C*')
+    end
+
+    # Convert Arrays of bytes returned by DBus to Strings of bytes.
+    def _deserialize_value(val, raw: false)
+      val = val.pack('C*')
+      val = @desc.post_process(val) if !raw && @desc.read_processors?
+      val
+    end
+
+  end
+end

data/lib/ble/db_eddystone.rb

@@ -0,0 +1,50 @@
+module BLE
+module Service
+    add 'ee0c2080-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone-URL Beacon Configuration'
+end
+end
+
+module BLE
+class Characteristic
+  add 'ee0c2081-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Lock State',
+        nick: :esurl_lockstate
+
+    add 'ee0c2082-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Lock',
+        nick: :esurl_lock
+
+    add 'ee0c2083-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Unlock',
+        nick: :esurl_unlock
+
+    add 'ee0c2084-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone URL Data',
+        nick: :esurl_data
+
+    add 'ee0c2085-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Flags',
+        nick: :esurl_flags
+
+    add 'ee0c2086-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Adv Tx Power Levels',
+        nick: :esurl_adv_txpower_levels
+
+    add 'ee0c2087-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone TX power mode',
+        nick: :esurl_txpower_mode
+
+    add 'ee0c2088-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Beacon period',
+        nick: :esurl_beacon_period
+
+    add 'ee0c2089-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Reset',
+        nick: :esurl_reset
+
+    add 'ee0c208a-8786-40ba-ab96-99b91ac981d8',
+        name: 'Eddystone Radio Tx Power Levels',
+        nick: :esurl_radio_txpower_levels
+end
+end

data/lib/ble/db_nordic.rb

@@ -0,0 +1,26 @@
+module BLE
+module Service
+    add '00001530-1212-efde-1523-785feabcd123',
+        name: 'Nordic Device Firmware Update Service'
+
+    add '6e400001-b5a3-f393-e0a9-e50e24dcca9e',
+        name: 'Nordic UART Service'
+end
+end
+
+
+module BLE
+class Characteristic
+  add '00001531-1212-efde-1523-785feabcd123', # WriteWithoutResponse
+        name: 'DFU Packet'
+
+    add '00001532-1212-efde-1523-785feabcd123', # Write,Notify
+        name: 'DFU Control Point'
+
+    add '6e400002-b5a3-f393-e0a9-e50e24dcca9e',
+        name: 'UART TX'
+
+    add '6e400003-b5a3-f393-e0a9-e50e24dcca9e',
+        name: 'UART RX'
+end
+end

data/lib/ble/db_sig_characteristic.rb

@@ -0,0 +1,142 @@
+module BLE
+  class Characteristic
+    #   C         | Integer | 8-bit unsigned (unsigned char)
+    #   S         | Integer | 16-bit unsigned, native endian (uint16_t)
+    #   L         | Integer | 32-bit unsigned, native endian (uint32_t)
+    #   Q         | Integer | 64-bit unsigned, native endian (uint64_t)
+    #             |         |
+    #   c         | Integer | 8-bit signed (signed char)
+    #   s         | Integer | 16-bit signed, native endian (int16_t)
+    #   l         | Integer | 32-bit signed, native endian (int32_t)
+    #   q         | Integer | 64-bit signed, native endian (int64_t)
+    #
+    #   <         | Little endian
+    #   >         | Big endian
+
+    add 0x2A07,
+        name: 'Tx Power Level',
+        type: 'org.bluetooth.characteristic.tx_power_level',
+        vrfy: ->(x) { (-100..20).include?(c) },
+          in: ->(s) { s.unpack('c').first },
+         out: ->(v) { [ v ].pack('c') }
+
+    add 0x2A23,
+        name: 'System ID',
+        type: 'org.bluetooth.characteristic.system_id',
+        vrfy: ->(x) { (0..1099511627775).include?(x[0]) &&
+                      (0..16777215     ).include?(x[1])},
+          in: ->(s) { raise NotYetImplemented },
+         out: ->(v) { raise NotYetImplemented }
+
+    add 0x2A24,
+        name: 'Model Number String',
+        type: 'org.bluetooth.characteristic.model_number_string',
+          in: ->(s) { s.force_encoding('UTF-8') },
+         out: ->(v) { v.encode('UTF-8') }
+
+    add 0x2A25,
+        name: 'Serial Number String',
+        type: 'org.bluetooth.characteristic.serial_number_string',
+          in: ->(s) { s.force_encoding('UTF-8') },
+         out: ->(v) { v.encode('UTF-8') }
+
+    add 0x2A26,
+        name: 'Firmware Revision String',
+        type: 'org.bluetooth.characteristic.firmware_revision_string',
+          in: ->(s) { s.force_encoding('UTF-8') },
+         out: ->(v) { v.encode('UTF-8') }
+
+    add 0x2A27,
+        name: 'Hardware Revision String',
+        type: 'org.bluetooth.characteristic.hardware_revision_string',
+          in: ->(s) { s.force_encoding('UTF-8') },
+         out: ->(v) { v.encode('UTF-8') }
+
+    add 0x2A28,
+        name: 'Software Revision String',
+        type: 'org.bluetooth.characteristic.software_revision_string',
+          in: ->(s) { s.force_encoding('UTF-8') },
+         out: ->(v) { v.encode('UTF-8') }
+
+    add 0x2A29,
+        name: 'Manufacturer Name String',
+        type: 'org.bluetooth.characteristic.manufacturer_name_string',
+          in: ->(s) { s.force_encoding('UTF-8') },
+         out: ->(v) { v.encode('UTF-8') }
+
+    add 0x2A2A,
+        name: 'IEEE 11073-20601 Regulatory Certification Data List',
+        type: 'org.bluetooth.characteristic.ieee_11073-20601_regulatory_certification_data_list',
+          in: ->(s) { raise NotYetImplemented },
+         out: ->(v) { raise NotYetImplemented }
+
+    add 0x2A50,
+        name: 'PnP ID',
+        type: 'org.bluetooth.characteristic.pnp_id',
+         in: ->(s) { vendor_src, vendor_id,
+                     product_id, product_version = s.unpack('CS<S<S<')
+                     vendor_src = case vendor_src
+                                  when 1 then :bluetooth_sig
+                                  when 2 then :usb_forum
+                                  else        :reserved
+                                  end
+                     [ vendor_src, vendor_id,
+                       product_id, product_version ] },
+         out: ->(v) { raise NotYetImplemented }
+
+
+    add 0x2A6E,
+        name: 'Temperature',
+        type: 'org.bluetooth.characteristic.temperature',
+        vrfy: ->(x) { (0..100).include?(x) },
+          in: ->(s) { s.unpack('s<').first.to_f / 100 },
+         out: ->(v) { [ v*100 ].pack('s<') }
+
+    add 0x2A76,
+        name: 'UV Index',
+        type: 'org.bluetooth.characteristic.uv_index',
+          in: ->(s) { s.unpack('C').first },
+         out: ->(v) { [ v ].pack('C') }
+
+    add 0x2A77,
+        name: 'Irradiance',
+        type: 'org.bluetooth.characteristic.irradiance',
+          in: ->(s) { s.unpack('S<').first.to_f / 10 },
+         out: ->(v) { [ v*10 ].pack('S<') }
+
+    add 0x2A7A,
+        name: 'Heat Index',
+        type: 'org.bluetooth.characteristic.heat_index',
+          in: ->(s) { s.unpack('c').first },
+         out: ->(v) { [ v ].pack('c') }
+
+    add 0x2A19,
+        name: 'Battery Level',
+        type: 'org.bluetooth.characteristic.battery_level',
+        vrfy: ->(x) { (0..100).include?(x) },
+          in: ->(s) { s.unpack('C').first },
+         out: ->(v) { [ v ].pack('C') }
+
+    add 0x2A6F,
+        name: 'Humidity',
+        type: 'org.bluetooth.characteristic.humidity',
+        vrfy: ->(x) { (0..100).include?(x) },
+          in: ->(s) { s.unpack('S<').first.to_f / 100 },
+         out: ->(v) { [ v*100 ].pack('S<') }
+
+    add 0x2A6D,
+        name: 'Pressure',
+        type: 'org.bluetooth.characteristic.pressure',
+        vrfy: ->(x) { x >= 0 },
+          in: ->(s) { s.unpack('L<').first.to_f / 10 },
+         out: ->(v) { [ v*10 ].pack('L<') }
+
+    add 0x2AB3,
+        name: 'Altitude',
+        type: 'org.bluetooth.characteristic.altitude',
+        vrfy: ->(x) { x >= 0 },
+          in: ->(s) { s.unpack('S<').first },
+          out: ->(v) { [ v ].pack('S<') }
+
+end
+end