surface_master 0.2.0 → 0.2.1

data/lib/surface_master/interaction.rb

@@ -1,5 +1,6 @@
 module SurfaceMaster
-  # Base class for event-based drivers.  Sub-classes should extend the constructor, and implement `respond_to_action`
+  # Base class for event-based drivers.  Sub-classes should extend the constructor, and implement
+  # `respond_to_action`, etc.
   class Interaction
     include Logging
 
@@ -12,10 +13,9 @@ module SurfaceMaster
       logger.debug "Initializing #{self.class}##{object_id} with #{opts.inspect}"
 
       @use_threads  = opts[:use_threads] || true
-      @device       = opts[:device]
-      @device     ||= @device_class.new(opts.merge(input: true,
-                                                   output: true,
-                                                   logger: opts[:logger]))
+      @device       = opts[:device] || @device_class.new(opts.merge(input: true,
+                                                                    output: true,
+                                                                    logger: opts[:logger]))
       @latency      = (opts[:latency] || 0.001).to_f.abs
       @active       = false
 
@@ -36,35 +36,10 @@ module SurfaceMaster
     def start(opts = nil)
       logger.debug "Starting #{self.class}##{object_id}"
 
-      opts = { detached: false }.merge(opts || {})
+      opts              = { detached: false }.merge(opts || {})
+      @active           = true
+      @reader_thread  ||= create_reader_thread
 
-      @active = true
-
-      @reader_thread ||= Thread.new do
-        begin
-          while @active do
-            @device.read.each do |action|
-              if @use_threads
-                action_thread = Thread.new(action) do |act|
-                  respond_to_action(act)
-                end
-                @action_threads.add(action_thread)
-              else
-                respond_to_action(action)
-              end
-            end
-            sleep @latency# if @latency > 0.0
-          end
-        rescue Portmidi::DeviceError => e
-          logger.fatal "Could not read from device, stopping reader!"
-          raise SurfaceMaster::CommunicationError.new(e)
-        rescue Exception => e
-          logger.fatal "Unkown error, stopping reader: #{e.inspect}"
-          raise e
-        ensure
-          @device.reset!
-        end
-      end
       @reader_thread.join unless opts[:detached]
     end
 
@@ -78,28 +53,18 @@ module SurfaceMaster
         @reader_thread = nil
       end
     ensure
-      @action_threads.list.each do |thread|
-        begin
-          thread.kill
-          thread.join
-        rescue StandardException => e # TODO: RuntimeError, Exception, or this?
-          logger.error "Error when killing action thread: #{e.inspect}"
-        end
-      end
+      kill_action_threads!
       nil
     end
 
     def response_to(types = :all, state = :both, opts = nil, &block)
-      logger.debug "Setting response to #{types.inspect} for state #{state.inspect} with #{opts.inspect}"
+      logger.debug "Setting response to #{types.inspect} for state #{state.inspect} with"\
+        " #{opts.inspect}"
       types = Array(types)
       opts ||= {}
       no_response_to(types, state) if opts[:exclusive] == true
-      Array(state == :both ? %i(down up) : state).each do |st|
-        types.each do |type|
-          combined_types(type, opts).each do |combined_type|
-            responses[combined_type][st] << block
-          end
-        end
+      expand_states(state).each do |st|
+        add_response_for_state!(types, opts, st, block)
       end
       nil
     end
@@ -107,12 +72,8 @@ module SurfaceMaster
     def no_response_to(types = nil, state = :both, opts = nil)
       logger.debug "Removing response to #{types.inspect} for state #{state.inspect}"
       types = Array(types)
-      Array(state == :both ? %i(down up) : state).each do |st|
-        types.each do |type|
-          combined_types(type, opts).each do |combined_type|
-            responses[combined_type][st].clear
-          end
-        end
+      expand_states(state).each do |st|
+        clear_responses_for_state!(types, opts, st)
       end
       nil
     end
@@ -123,11 +84,76 @@ module SurfaceMaster
 
   protected
 
+    def create_reader_thread
+      Thread.new do
+        guard_input_and_reset_at_end! do
+          while @active
+            @device.read.each { |action| handle_action(action) }
+            sleep @latency if @latency && @latency > 0.0
+          end
+        end
+      end
+    end
+
+    def guard_input_and_reset_at_end!(&block)
+      block.call
+    rescue Portmidi::DeviceError => e
+      logger.fatal "Could not read from device, stopping reader!"
+      raise SurfaceMaster::CommunicationError, e
+    rescue Exception => e
+      logger.fatal "Unkown error, stopping reader: #{e.inspect}"
+      raise e
+    ensure
+      @device.reset!
+    end
+
+    def kill_action_threads!
+      @action_threads.list.each do |thread|
+        begin
+          thread.kill
+          thread.join
+        rescue StandardException => e # TODO: RuntimeError, Exception, or this?
+          logger.error "Error when killing action thread: #{e.inspect}"
+        end
+      end
+    end
+
+    def add_response_for_state!(types, opts, state, block)
+      response_groups_for(types, opts, state) do |responses|
+        responses << block
+      end
+    end
+
+    def clear_responses_for_state!(types, opts, state)
+      response_groups_for(types, opts, state, &:clear)
+    end
+
+    def response_groups_for(types, opts, state, &block)
+      types.each do |type|
+        combined_types(type, opts).each do |combined_type|
+          block.call(responses[combined_type][state])
+        end
+      end
+    end
+
+    def expand_states(state); Array(state == :both ? %i(down up) : state); end
+
+    def handle_action(action)
+      if @use_threads
+        action_thread = Thread.new(action) do |act|
+          respond_to_action(act)
+        end
+        @action_threads.add(action_thread)
+      else
+        respond_to_action(action)
+      end
+    end
+
     def responses
       # TODO: Generalize for arbitrary actions...
       @responses ||= Hash.new { |hash, key| hash[key] = { down: [], up: [] } }
     end
 
-    def respond_to_action(action); end
+    def respond_to_action(_action); end
   end
 end

data/lib/surface_master/launchpad/device.rb

@@ -1,5 +1,6 @@
 module SurfaceMaster
   module Launchpad
+    # Low-level interface to Novation Launchpad Mark 2 control surface.
     class Device < SurfaceMaster::Device
       include MIDICodes
 
@@ -54,76 +55,101 @@ module SurfaceMaster
       # TODO: Support more of the LaunchPad Mark 2's functionality.
 
       def change(opts = nil)
+        fail NoOutputAllowedError unless output_enabled?
+
         opts ||= {}
         command, payload = color_payload(opts)
         sysex!(command, payload[:led], payload[:color])
+        nil
       end
 
       def changes(values)
-        msg_by_command = {}
-        values.each do |value|
-          command, payload = color_payload(value)
-          (msg_by_command[command] ||= []) << payload
-        end
-        msg_by_command.each do |command, payloads|
-          # The documented batch size for RGB LED updates is 80.  The docs lie, at least on my current
-          # firmware version -- anything above 62 crashes the device hard.
+        fail NoOutputAllowedError unless output_enabled?
+
+        organize_commands(values).each do |command, payloads|
+          # The documented batch size for RGB LED updates is 80.  The docs lie, at least on my
+          # current firmware version -- anything above 62 crashes the device hard.
           while (slice = payloads.shift(62)).length > 0
-            sysex!(command, *slice.map { |payload| [payload[:led], payload[:color]] })
+            messages = slice.map { |payload| [payload[:led], payload[:color]] }
+            sysex!(command, *messages)
           end
         end
+        nil
       end
 
       def read
+        fail NoInputAllowedError unless input_enabled?
         super.collect do |input|
-          note          = input[:note]
-          input[:type]  = CODE_NOTE_TO_TYPE[[input[:code], note]] || :grid
-          if input[:type] == :grid
-            note      = note - 11
-            input[:x] = note % 10
-            input[:y] = note / 10
-          end
+          note                  = input.delete(:note)
+          input[:type]          = CODE_NOTE_TO_TYPE[[input.delete(:code), note]] || :grid
+          input[:x], input[:y]  = decode_grid_coord(note) if input[:type] == :grid
+          input.delete(:velocity)
           input
         end
       end
 
     protected
 
+      def organize_commands(values)
+        msg_by_command = {}
+        values.each do |value|
+          command, payload = color_payload(value)
+          (msg_by_command[command] ||= []) << payload
+        end
+        msg_by_command
+      end
+
+      def decode_grid_coord(note)
+        note -= 11
+        x     = note % 10
+        y     = note / 10
+        [x, y]
+      end
+
       def layout!(mode); sysex!(0x22, mode); end
       def sysex_prefix; @sysex_prefix ||= super + [0x00, 0x20, 0x29, 0x02, 0x18]; end
 
       def decode_led(opts)
         case
-        when opts[:cc]
-          [:cc, TYPE_TO_NOTE[opts[:cc]]]
-        when opts[:grid]
-          if opts[:grid] == :all
-            [:all, nil]
-          else
-            [:grid, (opts[:grid][1] * 10) + opts[:grid][0] + 11]
-          end
-        when opts[:column]
-          [:column, opts[:column]]
-        when opts[:row]
-          [:row, opts[:row]]
+        when opts[:cc]      then [:cc, TYPE_TO_NOTE[opts[:cc]]]
+        when opts[:grid]    then decode_grid_led(opts)
+        when opts[:column]  then [:column, opts[:column]]
+        when opts[:row]     then [:row, opts[:row]]
         end
+      rescue
+        raise SurfaceMaster::Launchpad::NoValidGridCoordinatesError
       end
 
-      TYPE_TO_COMMAND = { cc:     0x0B,
-                          grid:   0x0B,
-                          column: 0x0C,
-                          row:    0x0D,
-                          all:    0x0E }.freeze
-      def color_payload(opts)
-        type, led = decode_led(opts)
-        command   = TYPE_TO_COMMAND[type]
-        case type
-        when :cc, :grid
-          color   = [opts[:red] || 0x00, opts[:green] || 0x00, opts[:blue] || 0x00]
-        when :column, :row, :all
-          color   = opts[:color] || 0x00
+      def decode_grid_led(opts)
+        if opts[:grid] == :all
+          [:all, nil]
+        else
+          check_xy_values!(opts[:grid])
+          [:grid, (opts[:grid][1] * 10) + opts[:grid][0] + 11]
         end
-        [command, { led: led, color: color }]
+      end
+
+      def check_xy_values!(xy_pair)
+        x = xy_pair[0]
+        y = xy_pair[1]
+        return unless xy_pair.length != 2 ||
+                      !coord_in_range?(x) ||
+                      !coord_in_range?(y)
+
+        fail SurfaceMaster::Launchpad::NoValidGridCoordinatesError
+      end
+
+      def coord_in_range?(val); val && val >= 0 && val <= 7; end
+
+      def color_payload(opts)
+        # Hard-coded to single-LED RGB update right now.
+        # For paletted changes, commands available include:
+        # 0x0C -> Column
+        # 0x0D -> Row
+        # 0x0E -> All LEDs
+        [0x0B,
+         { led:   decode_led(opts),
+           color: [opts[:red] || 0x00, opts[:green] || 0x00, opts[:blue] || 0x00] }]
       end
 
       def output!(status, data1, data2)
@@ -133,27 +159,13 @@ module SurfaceMaster
       def outputs!(*messages)
         messages = Array(messages)
         if @output.nil?
-          logger.error "trying to write to device that's not been initialized for output"
-          raise SurfaceMaster::NoOutputAllowedError
+          logger.error "trying to write to device not open for output"
+          fail SurfaceMaster::NoOutputAllowedError
         end
         logger.debug "writing messages to launchpad:\n  #{messages.join("\n  ")}" if logger.debug?
         @output.write(messages)
         nil
       end
-
-      def note(type, opts)
-        note = TYPE_TO_NOTE[type]
-        if note.nil?
-          x = (opts[:x] || -1).to_i
-          y = (opts[:y] || -1).to_i
-          if x < 0 || x > 7 || y < 0 || y > 7
-            logger.error "wrong coordinates specified: x=#{x}, y=#{y}"
-            raise NoValidGridCoordinatesError.new("you need to specify valid coordinates (x/y, 0-7, from top left), you specified: x=#{x}, y=#{y}")
-          end
-          note = y * 10 + x
-        end
-        note
-      end
     end
   end
 end

data/lib/surface_master/launchpad/errors.rb

@@ -1,11 +1,10 @@
-module Launchpad
-  # Generic launchpad error.
-  class LaunchpadError < SurfaceMaster::GenericError; end
+module SurfaceMaster
+  module Launchpad
+    # Generic launchpad error.
+    class LaunchpadError < SurfaceMaster::GenericError; end
 
-  # Error raised when <tt>x/y</tt> coordinates outside of the grid
-  # or none were specified.
-  class NoValidGridCoordinatesError < LaunchpadError; end
-
-  # Error raised when wrong brightness was specified.
-  class NoValidBrightnessError < LaunchpadError; end
+    # Error raised when <tt>x/y</tt> coordinates outside of the grid
+    # or none were specified.
+    class NoValidGridCoordinatesError < LaunchpadError; end
+  end
 end

data/lib/surface_master/launchpad/interaction.rb

@@ -1,43 +1,13 @@
 module SurfaceMaster
   module Launchpad
+    # Higher-level interface to Novation Launchpad Mark 2, providing an input
+    # handling loop and event-hooks for input events.
     class Interaction < SurfaceMaster::Interaction
       def initialize(opts = nil)
         @device_class = Device
         super(opts)
       end
 
-      # def response_to(types = :all, state = :both, opts = nil, &block)
-      #   logger.debug "setting response to #{types.inspect} for state #{state.inspect} with #{opts.inspect}"
-      #   types = Array(types)
-      #   opts ||= {}
-      #   no_response_to(types, state) if opts[:exclusive] == true
-      #   Array(state == :both ? %i(down up) : state).each do |st|
-      #     types.each do |type|
-      #       combined_types(type, opts).each do |combined_type|
-      #         responses[combined_type][st] << block
-      #       end
-      #     end
-      #   end
-      #   nil
-      # end
-
-      # def no_response_to(types = nil, state = :both, opts = nil)
-      #   logger.debug "removing response to #{types.inspect} for state #{state.inspect}"
-      #   types = Array(types)
-      #   Array(state == :both ? %i(down up) : state).each do |st|
-      #     types.each do |type|
-      #       combined_types(type, opts).each do |combined_type|
-      #         responses[combined_type][st].clear
-      #       end
-      #     end
-      #   end
-      #   nil
-      # end
-
-      # def respond_to(type, state, opts = nil)
-      #   respond_to_action((opts || {}).merge(type: type, state: state))
-      # end
-
     protected
 
       def responses
@@ -56,8 +26,8 @@ module SurfaceMaster
           x = grid_range(opts[:x])
           y = grid_range(opts[:y])
           return [:grid] if x.nil? && y.nil?  # whole grid
-          x ||= ['-']                         # whole row
-          y ||= ['-']                         # whole column
+          x ||= ["-"]                         # whole row
+          y ||= ["-"]                         # whole column
           x.product(y).map { |xx, yy| :"grid#{xx}#{yy}" }
         else
           [type.to_sym]
@@ -65,21 +35,33 @@ module SurfaceMaster
       end
 
       def respond_to_action(action)
+        mappings_for_action(action).each do |block|
+          block.call(self, action)
+        end
+        nil
+      rescue Exception => e # TODO: StandardException, RuntimeError, or Exception?
+        logger.error "Error when responding to action #{action.inspect}: #{e.inspect}"
+        raise e
+      end
+
+      def mappings_for_action(action)
         type    = action[:type].to_sym
         state   = action[:state].to_sym
         actions = []
         if type == :grid
-          actions += responses[:"grid#{action[:x]}#{action[:y]}"][state]
-          actions += responses[:"grid#{action[:x]}-"][state]
-          actions += responses[:"grid-#{action[:y]}"][state]
+          actions += mappings_for_grid_action(state, action[:x], action[:y])
         end
         actions += responses[type][state]
         actions += responses[:all][state]
-        actions.compact.each {|block| block.call(self, action)}
-        nil
-      rescue Exception => e # TODO: StandardException, RuntimeError, or Exception?
-        logger.error "Error when responding to action #{action.inspect}: #{e.inspect}"
-        raise e
+        actions.compact
+      end
+
+      def mappings_for_grid_action(state, x, y)
+        actions = []
+        actions += responses[:"grid#{x}#{y}"][state]
+        actions += responses[:"grid#{x}-"][state]
+        actions += responses[:"grid-#{y}"][state]
+        actions
       end
     end
   end

data/lib/surface_master/orbit/device.rb

@@ -1,5 +1,6 @@
 module SurfaceMaster
   module Orbit
+    # Low-level interface to Numark Orbit wireless MIDI control surface.
     class Device < SurfaceMaster::Device
       include MIDICodes
 
@@ -11,91 +12,8 @@ module SurfaceMaster
 
       def reset!
         # TODO: This... doesn't appear to work.  At all.
-        mappings = [0x03, 0x01, 0x70,
-
-                    0x00, 0x00, 0x00,
-                    0x00, 0x04, 0x00,
-                    0x00, 0x08, 0x00,
-                    0x00, 0x0C, 0x00,
-                    0x00, 0x01, 0x00,
-                    0x00, 0x05, 0x00,
-                    0x00, 0x09, 0x00,
-                    0x00, 0x0D, 0x00,
-                    0x00, 0x02, 0x00,
-                    0x00, 0x06, 0x00,
-                    0x00, 0x0A, 0x00,
-                    0x00, 0x0E, 0x00,
-                    0x00, 0x03, 0x00,
-                    0x00, 0x07, 0x00,
-                    0x00, 0x0B, 0x00,
-                    0x00, 0x0F, 0x00,
-                    0x01, 0x00, 0x00,
-                    0x01, 0x04, 0x00,
-                    0x01, 0x08, 0x00,
-                    0x01, 0x0C, 0x00,
-                    0x01, 0x01, 0x00,
-                    0x01, 0x05, 0x00,
-                    0x01, 0x09, 0x00,
-                    0x01, 0x0D, 0x00,
-                    0x01, 0x02, 0x00,
-                    0x01, 0x06, 0x00,
-                    0x01, 0x0A, 0x00,
-                    0x01, 0x0E, 0x00,
-                    0x01, 0x03, 0x00,
-                    0x01, 0x07, 0x00,
-                    0x01, 0x0B, 0x00,
-                    0x01, 0x0F, 0x00,
-                    0x02, 0x00, 0x00,
-                    0x02, 0x04, 0x00,
-                    0x02, 0x08, 0x00,
-                    0x02, 0x0C, 0x00,
-                    0x02, 0x01, 0x00,
-                    0x02, 0x05, 0x00,
-                    0x02, 0x09, 0x00,
-                    0x02, 0x0D, 0x00,
-                    0x02, 0x02, 0x00,
-                    0x02, 0x06, 0x00,
-                    0x02, 0x0A, 0x00,
-                    0x02, 0x0E, 0x00,
-                    0x02, 0x03, 0x00,
-                    0x02, 0x07, 0x00,
-                    0x02, 0x0B, 0x00,
-                    0x02, 0x0F, 0x00,
-                    0x03, 0x00, 0x00,
-                    0x03, 0x04, 0x00,
-                    0x03, 0x08, 0x00,
-                    0x03, 0x0C, 0x00,
-                    0x03, 0x01, 0x00,
-                    0x03, 0x05, 0x00,
-                    0x03, 0x09, 0x00,
-                    0x03, 0x0D, 0x00,
-                    0x03, 0x02, 0x00,
-                    0x03, 0x06, 0x00,
-                    0x03, 0x0A, 0x00,
-                    0x03, 0x0E, 0x00,
-                    0x03, 0x03, 0x00,
-                    0x03, 0x07, 0x00,
-                    0x03, 0x0B, 0x00,
-                    0x03, 0x0F, 0x00,
-                    0x00, 0x00, 0x01,
-                    0x00, 0x02, 0x00,
-                    0x03, 0x00, 0x00,
-                    0x01, 0x01, 0x01,
-                    0x02, 0x01, 0x03,
-                    0x01, 0x00, 0x02,
-                    0x01, 0x02, 0x02,
-                    0x02, 0x03, 0x02,
-                    0x00, 0x03, 0x01,
-                    0x03, 0x02, 0x03,
-                    0x03, 0x03, 0x0C,
-                    0x00, 0x0D, 0x00,
-                    0x0C, 0x00, 0x0D,
-                    0x00, 0x0C, 0x00,
-                    0x0D, 0x00, 0x0C,
-                    0x00, 0x0D, 0x00]
-
-        if (result = sysex!(*mappings)) != 0
-          raise "Expected success (0) setting mappings, got: #{result}"
+        if (result = sysex!(*MAPPINGS)) != 0
+          fail "Expected success (0) setting mappings, got: #{result}"
         end
         sysex!(0x01, 0x00, 0x00)
       end
@@ -108,6 +26,88 @@ module SurfaceMaster
 
     protected
 
+      MAPPINGS = [0x03, 0x01, 0x70,
+                  0x00, 0x00, 0x00,
+                  0x00, 0x04, 0x00,
+                  0x00, 0x08, 0x00,
+                  0x00, 0x0C, 0x00,
+                  0x00, 0x01, 0x00,
+                  0x00, 0x05, 0x00,
+                  0x00, 0x09, 0x00,
+                  0x00, 0x0D, 0x00,
+                  0x00, 0x02, 0x00,
+                  0x00, 0x06, 0x00,
+                  0x00, 0x0A, 0x00,
+                  0x00, 0x0E, 0x00,
+                  0x00, 0x03, 0x00,
+                  0x00, 0x07, 0x00,
+                  0x00, 0x0B, 0x00,
+                  0x00, 0x0F, 0x00,
+                  0x01, 0x00, 0x00,
+                  0x01, 0x04, 0x00,
+                  0x01, 0x08, 0x00,
+                  0x01, 0x0C, 0x00,
+                  0x01, 0x01, 0x00,
+                  0x01, 0x05, 0x00,
+                  0x01, 0x09, 0x00,
+                  0x01, 0x0D, 0x00,
+                  0x01, 0x02, 0x00,
+                  0x01, 0x06, 0x00,
+                  0x01, 0x0A, 0x00,
+                  0x01, 0x0E, 0x00,
+                  0x01, 0x03, 0x00,
+                  0x01, 0x07, 0x00,
+                  0x01, 0x0B, 0x00,
+                  0x01, 0x0F, 0x00,
+                  0x02, 0x00, 0x00,
+                  0x02, 0x04, 0x00,
+                  0x02, 0x08, 0x00,
+                  0x02, 0x0C, 0x00,
+                  0x02, 0x01, 0x00,
+                  0x02, 0x05, 0x00,
+                  0x02, 0x09, 0x00,
+                  0x02, 0x0D, 0x00,
+                  0x02, 0x02, 0x00,
+                  0x02, 0x06, 0x00,
+                  0x02, 0x0A, 0x00,
+                  0x02, 0x0E, 0x00,
+                  0x02, 0x03, 0x00,
+                  0x02, 0x07, 0x00,
+                  0x02, 0x0B, 0x00,
+                  0x02, 0x0F, 0x00,
+                  0x03, 0x00, 0x00,
+                  0x03, 0x04, 0x00,
+                  0x03, 0x08, 0x00,
+                  0x03, 0x0C, 0x00,
+                  0x03, 0x01, 0x00,
+                  0x03, 0x05, 0x00,
+                  0x03, 0x09, 0x00,
+                  0x03, 0x0D, 0x00,
+                  0x03, 0x02, 0x00,
+                  0x03, 0x06, 0x00,
+                  0x03, 0x0A, 0x00,
+                  0x03, 0x0E, 0x00,
+                  0x03, 0x03, 0x00,
+                  0x03, 0x07, 0x00,
+                  0x03, 0x0B, 0x00,
+                  0x03, 0x0F, 0x00,
+                  0x00, 0x00, 0x01,
+                  0x00, 0x02, 0x00,
+                  0x03, 0x00, 0x00,
+                  0x01, 0x01, 0x01,
+                  0x02, 0x01, 0x03,
+                  0x01, 0x00, 0x02,
+                  0x01, 0x02, 0x02,
+                  0x02, 0x03, 0x02,
+                  0x00, 0x03, 0x01,
+                  0x03, 0x02, 0x03,
+                  0x03, 0x03, 0x0C,
+                  0x00, 0x0D, 0x00,
+                  0x0C, 0x00, 0x0D,
+                  0x00, 0x0C, 0x00,
+                  0x0D, 0x00, 0x0C,
+                  0x00, 0x0D, 0x00]
+
       def sysex_prefix; @sysex_prefix ||= super + [0x00, 0x01, 0x3F, 0x2B]; end
 
       def decode_shoulder(decoded, note, _velocity)

data/lib/surface_master/orbit/interaction.rb

@@ -1,5 +1,6 @@
 module SurfaceMaster
   module Orbit
+    # Higher-level interface for Numark Orbit wireless MIDI control surface.
     class Interaction < SurfaceMaster::Interaction
       def initialize(opts = nil)
         @device_class = Device