surface_master 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0809d0fe24d9da2f41becb4e27a0ec785019c029
-  data.tar.gz: 43919aa3d44ec3006953501bebf6f3d5a4010f76
+  metadata.gz: f2b72c0db5f531114165b1bf813b7723de8daa62
+  data.tar.gz: 816e060bcc90c233e3fe80f994295a0d04222334
 SHA512:
-  metadata.gz: 0ab45e7ab7dc4761d108f5dd5dc758516bf35a93b6cc4ea0b5142ed80c2ac5a4c11469756762a57aea5de98a7821f79ed12ace9649bb4ec12ae85532b1bd4493
-  data.tar.gz: 4ede3f9b33450d69c3bcd250494426b4a66cda5d25c1907ce370fd4bc3a8c7a17cc1131d8d077c832fc4dad342854327c57440e25f522651a9a7593118ec2374
+  metadata.gz: 7d7e478d03cb7f4bfbb8dd29c527c374d4ad798054b04a3a9c6326d4ed42e56cd971c2830642715df5e9d851de8631342f6d02f215b4cd6c0394ec83e6af7206
+  data.tar.gz: 3252e00acc136cf55dee085e073266f65f7cdb63494f84ddcead0fb6bac150e73598fa9e922fc8aefdc58ec6cb9e5e7a608b6c8a4798e2b0141bfc66b8ca0147

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changes
 
+## v0.4.0
+
+* Jettison threaded input handling.
+* More Numark Orbit handling (output is still a problem).
+
+
+## v0.3.0
+
+* __BREAKING CHANGE__: Change Orbit interface to more closely follow conventions established with Novation Launchpad driver.
+* Add preliminary `Interaction` class for Numark Orbit.
+    * See `examples/orbit_interaction.rb`.
+* Fix exclusive binding in `Interaction` to not nuke coarser bindings entirely.
+* Rename `examples/orbit_testbed.rb` to `examples/orbit_device.rb`.
+* Rename `examples/monitor.rb` to `examples/system_monitor.rb`.
+* Rename `examples/launchpad_testbed.rb` to `examples/launchpad_playground.rb`.
+
+
 ## v0.2.1
 
 * Missed a file rename.

data/docs/Numark_Orbit_QuickRef.md

@@ -1,5 +1,10 @@
 # Numark Orbit Quick Reference
 
+## Mappings
+
+Use the file `mappings/Orbit_Preset.json`, and be sure to hit `Send` several times, as it sometimes does not actually take.
+
+
 ## Low Battery Indicator
 
 Any blinking `Pad Bank Selectors` indicates the battery is low.

data/examples/{launchpad_testbed.rb → launchpad_playground.rb}

@@ -1,32 +1,52 @@
 #!/usr/bin/env ruby
+#
+# This file provides an example of using the Novation Launchpad Mark 2 using
+# event handlers to respond to buttons, and batch LED updates to update every
+# button on the board quite rapidly.
+#
+# Controls:
+#
+# * Press any grid button and observe that the color changes to white while it's held.  Any number
+#   of pads may be pressed simultaneously.
+# * The control buttons on the right will each channel-flip a quadrant of the board.  They act as
+#   toggles, to pressing them again undoes the effect.
+# * The `Mixer` button will terminate the simulation.
+#
+# Effects:
+#
+# * The color of a pad is applied in layers additively, with values clamped to white at the end:
+#     1. The base color for each grid pad is defined by its position with the color getting more
+#        green on the X axis, and more blue along the Y axis.  See `SCALE` for how steep the change
+#        is.
+#     2. Each quadrant adds in a specific color (see `QUADRANTS` below).
+#     3. The red/green/blue channels may be rotated for any given quadrant, if the relevant toggle
+#        is active.
+#     4. A sine-wave is applied to one or more channels (see `TIME_SCALE` for the speed of the sine
+#        wave).
+#     5. If a particular pad is pressed, the color is set to white.
+#
+# TODO: Input handling seems to interfere with frame rendering, as our FPS seems to "jump" to
+# TODO: insane values when a button is pressed.
+#
 require "rubygems"
 require "bundler/setup"
 Bundler.require(:default, :development)
 
 require "surface_master"
 
-# Flash:    F0h 00h 20h 29h 02h 18h 23h <LED> <Colour> F7h
-# Pulse:    F0h 00h 20h 29h 02h 18h 28h <LED> <Colour> F7h
-# Set all:  F0h 00h 20h 29h 02h 18h 0Eh <Colour> F7h
-# Set row:  F0h 00h 20h 29h 02h 18h 0Dh <Row> <Colour> F7h
-# Set col:  F0h 00h 20h 29h 02h 18h 0Ch <Column> <Colour> F7h
-
-# Configuration
-SCALE       = 2
+# Animation Configuration
+SCALE       = [2, 2]
 TIME_SCALE  = 4.0
+TIME_MASK   = { red: 0x3F, green: 0x00, blue: 0x00 }
+QUADRANTS = [[{ red: 0x2F, green: 0x00, blue: 0x00 }, { red: 0x00, green: 0x2F, blue: 0x00 }],
+             [{ red: 0x00, green: 0x00, blue: 0x2F }, { red: 0x2F, green: 0x2F, blue: 0x00 }]]
 
 # State
-QUADRANTS = [
-  [{ red: 0x2F, green: 0x00, blue: 0x00 }, { red: 0x00, green: 0x2F, blue: 0x00 }],
-  [{ red: 0x00, green: 0x00, blue: 0x2F }, { red: 0x2F, green: 0x2F, blue: 0x00 }],
-]
 FLIPPED = [[false, false], [false, false]]
 PRESSED = (0..7).map { |_x| (0..7).map { |_y| false } }
 NOW     = [Time.now.to_f]
 
 # Helpers
-CC      = %i(up down left right session user1 user2 scene1 scene2 scene3 scene4 scene5 scene6 scene7
-             scene8)
 GRID    = (0..7).map { |x| (0..7).map { |y| { grid: [x, y] } } }.flatten
 WHITE   = { red: 0x3F, green: 0x3F, blue: 0x3F }
 BLACK   = { red: 0x00, green: 0x00, blue: 0x00 }
@@ -41,15 +61,15 @@ end
 
 def positional_color(x, y)
   { red:   0x00,
-    green: (x * SCALE),
-    blue:  (y * SCALE) }
+    green: (x * SCALE[0]),
+    blue:  (y * SCALE[1]) }
 end
 
 def temporal_color(_x, _y)
   s_t = (Math.sin(NOW[0] * TIME_SCALE) * 0.5) + 0.5
-  { red:   (s_t * 0x3F).round,
-    green: 0x00,
-    blue:  0x00 }
+  { red:   (s_t * TIME_MASK[:red]).round,
+    green: (s_t * TIME_MASK[:green]).round,
+    blue:  (s_t * TIME_MASK[:blue]).round }
 end
 
 def clamp_color(color)
@@ -155,18 +175,38 @@ interaction.response_to(:mixer, :down) do |_interaction, _action|
   interaction.stop
 end
 interaction.change(red: 0x03, green: 0x00, blue: 0x00, cc: :mixer)
-BTN_COL = { red: 0x03, green: 0x03, blue: 0x03, cc: cc }
+BTN_COL = { red: 0x03, green: 0x03, blue: 0x03 }
 interaction.changes(%i(scene1 scene2 scene3 scene4).map { |cc| BTN_COL.merge(cc: cc) })
 
 init_board(interaction)
 input_thread = Thread.new do
   interaction.start
 end
-animation_thread = Thread.new do
+cumulative_time   = 0.0
+frame_times       = []
+min_frame_time    = Float::INFINITY
+max_frame_time    = 0.0
+animation_thread  = Thread.new do
   loop do
     begin
       NOW[0] = Time.now.to_f
       init_board(interaction)
+      elapsed           = Time.now.to_f - NOW[0]
+      cumulative_time  += elapsed
+      min_frame_time    = elapsed if elapsed < min_frame_time
+      max_frame_time    = elapsed if elapsed > max_frame_time
+      frame_times.push(elapsed)
+      frame_times.shift if frame_times.length > 60
+
+      # Show avg FPS once per second.
+      if cumulative_time >= 1.0
+        cumulative_time = 0.0
+        avg_frame_time = frame_times.inject(0.0) { |a, e| a + e } / frame_times.length
+        avg_rate = (1.0 / avg_frame_time)
+        max_rate = (1.0 / min_frame_time)
+        min_rate = (1.0 / max_frame_time)
+        puts "FPS: Average = %0.1f, Min = %0.1f, Max = %0.1f" % [avg_rate, min_rate, max_rate]
+      end
     rescue StandardError => e
       puts e.inspect
       puts e.backtrace.join("\n")

data/examples/{orbit_testbed.rb → orbit_device.rb}

@@ -1,16 +1,10 @@
 #!/usr/bin/env ruby
-# require "bignum"
 require "rubygems"
 require "bundler/setup"
 Bundler.require(:default, :development)
 
 require "surface_master"
 
-# Monkey-patching to make debugging easier.
-class Fixnum
-  def to_hex; "%02X" % self; end
-end
-
 SurfaceMaster.init!
 device = SurfaceMaster::Orbit::Device.new
 loop do

data/examples/orbit_interaction.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "bundler/setup"
+Bundler.require(:default, :development)
+
+require "surface_master"
+
+SurfaceMaster.init!
+interaction = SurfaceMaster::Orbit::Interaction.new
+interaction.response_to(:pad, :down) do |_inter, action|
+  puts "PAD DOWN: #{action.inspect}"
+end
+interaction.response_to(:pad, :up) do |_inter, action|
+  puts "PAD UP: #{action.inspect}"
+end
+interaction.response_to(:pad, :up, button: 1..4) do |_inter, action|
+  puts "LEFT COLUMN PAD UP: #{action.inspect}"
+end
+interaction.response_to(:pad, :up, button: 5..8, bank: 4, exclusive: true) do |_inter, action|
+  puts "SECOND-FROM-LEFT COLUMN PAD UP: #{action.inspect}"
+end
+
+interaction.response_to(:vknob, :update) do |_inter, action|
+  puts "ANY KNOB, ANY BANK (EXCEPT 2) TURNED: #{action.inspect}"
+end
+interaction.response_to(:vknob, :update, vknob: 3) do |_inter, action|
+  puts "KNOB 3, ANY BANK (EXCEPT 2) TURNED: #{action.inspect}"
+end
+interaction.response_to(:vknob, :update, bank: 2, exclusive: true) do |_inter, action|
+  puts "ANY KNOB, BANK 2 TURNED: #{action.inspect}"
+end
+interaction.response_to(:vknob, :update, bank: 4, vknob: 1) do |_inter, action|
+  puts "KNOB 1, BANK 4 TURNED: #{action.inspect}"
+end
+
+interaction.response_to(:accelerometer, :tilt) do |_inter, action|
+  puts "ANY AXIS TILT: #{action.inspect}"
+end
+interaction.response_to(:accelerometer, :tilt, axis: :x) do |_inter, action|
+  puts "X-AXIS TILT: #{action.inspect}"
+end
+
+interaction.response_to(:vknobs, :down) do |_inter, action|
+  puts "ANY VKNOB SELECTOR DOWN: #{action.inspect}"
+end
+interaction.response_to(:vknobs, :down, button: 2) do |_inter, action|
+  puts "VKNOB 2 SELECTOR DOWN: #{action.inspect}"
+end
+
+interaction.response_to(:banks, :down) do |_inter, action|
+  puts "ANY BANK SELECTOR DOWN: #{action.inspect}"
+end
+interaction.response_to(:banks, :down, button: 3) do |_inter, action|
+  puts "BANK 3 SELECTOR DOWN: #{action.inspect}"
+end
+
+interaction.response_to(:shoulder, :down) do |_inter, action|
+  puts "ANY SHOULDER DOWN: #{action.inspect}"
+end
+interaction.response_to(:shoulder, :up) do |_inter, action|
+  puts "ANY SHOULDER UP: #{action.inspect}"
+end
+interaction.response_to(:shoulder, :down, button: :left) do |_inter, action|
+  puts "LEFT SHOULDER DOWN: #{action.inspect}"
+end
+interaction.response_to(:shoulder, :up, button: :left) do |_inter, action|
+  puts "LEFT SHOULDER UP: #{action.inspect}"
+end
+
+puts "Starting input loop..."
+interaction.start

data/examples/orbit_playground.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+# Cycle Numark Orbit colors through a wheel.
+#
+# IMPORTANT: Set `MODE` below to `:wired`, or `:wireless`, as appropriate to
+# IMPORTANT: how your Numark Orbit is connected!
+#
+# NOTE: If the lights do not blank out when this starts, your device is in a
+# NOTE: bad state.  Push a config to it from the Numark Orbit Editor.  If that
+# NOTE: doesn't work, power-cycle it and try again!
+require "rubygems"
+require "bundler/setup"
+Bundler.require(:default, :development)
+
+require "surface_master"
+
+device = SurfaceMaster::Orbit::Device.new
+# The device seems to be notably less able to accept updates over wireless, and
+# perhaps because CoreMIDI has no backpressure, we can easily wind up hosed.
+# Before settling on new values here, run the process for *several full minutes*
+# and make sure the device continues accepting updates at the end!
+#
+# TODO: More thorough stress testing.
+#
+# TODO: Can we determine if the connection is wired/wireless automatically?
+#
+# TODO: Can we safely get input simultaneously?
+MODE      = :wired
+
+CONFIGS   = { wireless: { delay: 0.75,  offset: 0x03, use_read: true,   read_delay: 0.1 },
+              wired:    { delay: 0.1,  offset: 0x01, use_read: false,  read_delay: 0 } }
+MAPPINGS  =  [0x03, 0x01, 0x70,
+
+              0x00, 0x00, 0x00,
+              0x00, 0x04, 0x04,
+              0x00, 0x08, 0x08,
+              0x00, 0x0C, 0x0C,
+              0x00, 0x01, 0x01,
+              0x00, 0x05, 0x05,
+              0x00, 0x09, 0x09,
+              0x00, 0x0D, 0x0D,
+              0x00, 0x02, 0x02,
+              0x00, 0x06, 0x06,
+              0x00, 0x0A, 0x0A,
+              0x00, 0x0E, 0x0E,
+              0x00, 0x03, 0x03,
+              0x00, 0x07, 0x07,
+              0x00, 0x0B, 0x0B,
+              0x00, 0x0F, 0x0F,
+              0x01, 0x00, 0x10,
+              0x01, 0x04, 0x14,
+              0x01, 0x08, 0x18,
+              0x01, 0x0C, 0x1C,
+              0x01, 0x01, 0x11,
+              0x01, 0x05, 0x15,
+              0x01, 0x09, 0x19,
+              0x01, 0x0D, 0x1D,
+              0x01, 0x02, 0x12,
+              0x01, 0x06, 0x16,
+              0x01, 0x0A, 0x1A,
+              0x01, 0x0E, 0x1E,
+              0x01, 0x03, 0x13,
+              0x01, 0x07, 0x17,
+              0x01, 0x0B, 0x1B,
+              0x01, 0x0F, 0x1F,
+              0x02, 0x00, 0x20,
+              0x02, 0x04, 0x24,
+              0x02, 0x08, 0x28,
+              0x02, 0x0C, 0x2C,
+              0x02, 0x01, 0x21,
+              0x02, 0x05, 0x25,
+              0x02, 0x09, 0x29,
+              0x02, 0x0D, 0x2D,
+              0x02, 0x02, 0x22,
+              0x02, 0x06, 0x26,
+              0x02, 0x0A, 0x2A,
+              0x02, 0x0E, 0x2E,
+              0x02, 0x03, 0x23,
+              0x02, 0x07, 0x27,
+              0x02, 0x0B, 0x2B,
+              0x02, 0x0F, 0x2F,
+              0x03, 0x00, 0x30,
+              0x03, 0x04, 0x34,
+              0x03, 0x08, 0x38,
+              0x03, 0x0C, 0x3C,
+              0x03, 0x01, 0x31,
+              0x03, 0x05, 0x35,
+              0x03, 0x09, 0x39,
+              0x03, 0x0D, 0x3D,
+              0x03, 0x02, 0x32,
+              0x03, 0x06, 0x36,
+              0x03, 0x0A, 0x3A,
+              0x03, 0x0E, 0x3E,
+              0x03, 0x03, 0x33,
+              0x03, 0x07, 0x37,
+              0x03, 0x0B, 0x3B,
+              0x03, 0x0F, 0x3F,
+
+              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]
+READ_STATE = [0x01, 0x00, 0x00]
+
+delay       = CONFIGS[MODE][:delay]
+offset      = CONFIGS[MODE][:offset]
+use_read    = CONFIGS[MODE][:use_read]
+read_delay  = CONFIGS[MODE][:read_delay]
+
+sleep delay
+puts "Starting..."
+indices = (0..63).map { |n| 5 + (3 * n) }
+loop do
+  indices.each do |i|
+    MAPPINGS[i] = (MAPPINGS[i] + offset) % 0x3F
+  end
+  device.sysex!(*MAPPINGS)
+  if use_read
+    sleep read_delay
+    device.sysex!(*READ_STATE)
+  end
+  printf "."
+  sleep delay
+end

data/examples/{monitor.rb → system_monitor.rb}

@@ -39,14 +39,14 @@ end
 
 interaction = SurfaceMaster::Launchpad::Interaction.new
 cpu_bar     = Bar.new(interaction, 0, red: 0x3F, green: 0x00, blue: 0x00)
-io_bar      = Bar.new(interaction, 0, red: 0x00, green: 0x3F, blue: 0x00)
+io_bar      = Bar.new(interaction, 1, red: 0x00, green: 0x3F, blue: 0x00)
 monitor     = Thread.new do
   loop do
     fields      = `iostat -c 2 disk0`.split(/\n/).last.strip.split(/\s+/)
     cpu_pct     = 100 - fields[-4].to_i
     cpu_usage   = ((cpu_pct / 100.0) * 8.0).round.to_i
 
-    disk_pct    = (fields[2].to_f / 750.0) * 100.0
+    disk_pct    = ((fields[2].to_f / 750.0) * 100.0).round.to_i
     disk_usage  = ((disk_pct / 100.0) * 8.0).round.to_i
 
     puts "I/O=#{disk_pct}%, CPU=#{cpu_pct}%"

data/lib/surface_master/device.rb

@@ -51,10 +51,13 @@ module SurfaceMaster
       fail NoOutputAllowedError unless output_enabled?
       msg = sysex_msg(payload)
       logger.debug { "#{msg.length}: 0x#{msg.map { |b| '%02X' % b }.join(' ')}" }
-      @output.write_sysex(msg)
+      result = @output.write_sysex(msg)
+      if result != 0
+        puts "Sysex Error: #{Portmidi::PM_Map.Pm_GetErrorText(result)}"
+      end
+      result
     end
 
-
     def create_input_device(opts)
       return nil unless opts[:input]
       create_device(Portmidi.input_devices,

data/lib/surface_master/interaction.rb

@@ -12,14 +12,11 @@ module SurfaceMaster
       self.logger = opts[:logger]
       logger.debug "Initializing #{self.class}##{object_id} with #{opts.inspect}"
 
-      @use_threads  = opts[:use_threads] || true
       @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
-
-      @action_threads = ThreadGroup.new
     end
 
     def change(opts); @device.change(opts); end
@@ -33,36 +30,29 @@ module SurfaceMaster
 
     def closed?; @device.closed?; end
 
-    def start(opts = nil)
+    def start
       logger.debug "Starting #{self.class}##{object_id}"
 
-      opts              = { detached: false }.merge(opts || {})
-      @active           = true
-      @reader_thread  ||= create_reader_thread
-
-      @reader_thread.join unless opts[:detached]
+      @active = true
+      guard_input_and_reset_at_end! do
+        while @active
+          @device.read.each { |action| respond_to_action(action) }
+          sleep @latency if @latency && @latency > 0.0
+        end
+      end
     end
 
     def stop
       logger.debug "Stopping #{self.class}##{object_id}"
       @active = false
-      if @reader_thread
-        # run (resume from sleep) and wait for @reader_thread to end
-        @reader_thread.run if @reader_thread.alive?
-        @reader_thread.join
-        @reader_thread = nil
-      end
-    ensure
-      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}"
-      types = Array(types)
-      opts ||= {}
-      no_response_to(types, state) if opts[:exclusive] == true
+      types   = Array(types)
+      opts  ||= {}
+      no_response_to(types, state, opts) if opts[:exclusive] == true
       expand_states(state).each do |st|
         add_response_for_state!(types, opts, st, block)
       end
@@ -71,7 +61,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)
+      types   = Array(types)
+      opts  ||= {}
       expand_states(state).each do |st|
         clear_responses_for_state!(types, opts, st)
       end
@@ -84,15 +75,8 @@ 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
+    def expand(list)
+      list.map { |ll| ll.respond_to?(:to_a) ? ll.to_a : ll }.flatten
     end
 
     def guard_input_and_reset_at_end!(&block)
@@ -107,17 +91,6 @@ module SurfaceMaster
       @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
@@ -138,17 +111,6 @@ module SurfaceMaster
 
     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: [] } }

data/lib/surface_master/launchpad/device.rb

@@ -148,7 +148,7 @@ module SurfaceMaster
         # 0x0D -> Row
         # 0x0E -> All LEDs
         [0x0B,
-         { led:   decode_led(opts),
+         { led:   decode_led(opts)[1],
            color: [opts[:red] || 0x00, opts[:green] || 0x00, opts[:blue] || 0x00] }]
       end
 

data/lib/surface_master/orbit/device.rb

@@ -11,11 +11,52 @@ module SurfaceMaster
       end
 
       def reset!
-        # TODO: This... doesn't appear to work.  At all.
-        if (result = sysex!(*MAPPINGS)) != 0
-          fail "Expected success (0) setting mappings, got: #{result}"
+        # Skip Sysex begin, vendor header, command code, aaaaand sysex end --
+        # this will let us compare command vs. response payloads to determine
+        # if the state of the device is what we want.  Of course, sometimes it
+        # lies, but we can't do much about that.
+        expected_state = MAPPINGS[6..-2]
+        sysex!(MAPPINGS)
+        sleep 0.1
+        sysex!(READ_STATE)
+        current_state = nil
+        started_at    = Time.now.to_f
+        attempts      = 1
+        loop do
+          # TODO: It appears that accessing `buffer` is HIGHLY unsafe!  We may
+          # TODO: be OK if everyone's waiting on us to come back from this
+          # TODO: method before they begin clamoring for input, but that's just
+          # TODO: a guess right now.
+          if @input.buffer.length == 0
+            elapsed = Time.now.to_f - started_at
+            if elapsed > 4.0
+              logger.warn { "Timeout fetching state of Numark Orbit!" }
+              break
+            elsif elapsed > (1.0 * attempts)
+              logger.warn { "Asking for current state of Numark Orbit again!" }
+              attempts += 1
+              @output.puts(READ_STATE)
+              next
+            end
+            sleep 0.01
+            next
+          end
+          raw             = @input.gets
+          current_state   = raw.find { |ii| ii[:data][0] == 0xF0 }
+          break unless current_state.nil?
+        end
+
+        return unless current_state
+
+        current_state = current_state[:data][6..-2].dup
+        logger.debug { "Got state info from Numark Orbit!" }
+        if expected_state != current_state
+          logger.error { "UH OH!  Numark Orbit state didn't match what we sent!" }
+          logger.error { "Expected: #{expected_state.inspect}" }
+          logger.error { "Got:      #{current_state.inspect}" }
+        else
+          logger.debug { "Your Numark Orbit should be in the right state now." }
         end
-        sysex!(0x01, 0x00, 0x00)
       end
 
       def read
@@ -26,133 +67,140 @@ 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]
+      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]
+      READ_STATE = [0x01, 0x00, 0x00]
 
       def sysex_prefix; @sysex_prefix ||= super + [0x00, 0x01, 0x3F, 0x2B]; end
 
       def decode_shoulder(decoded, note, _velocity)
-        decoded[:control].merge!(SurfaceMaster::Orbit::Device::SHOULDERS[note])
+        decoded[:control] = decoded[:control].merge(SurfaceMaster::Orbit::Device::SHOULDERS[note])
         decoded
       end
 
       def decode_pad(decoded, note, _velocity)
-        decoded[:control][:button] = note
+        decoded[:control] = decoded[:control].merge(button: note + 1)
         decoded
       end
 
       def decode_knob(decoded, note, velocity)
-        decoded[:control][:bank]  = note + 1
-        decoded[:value]           = velocity
+        decoded[:control] = decoded[:control].merge(bank: note + 1)
+        decoded[:value]   = velocity
         decoded
       end
 
       def decode_control(decoded, note, velocity)
-        tmp         = SurfaceMaster::Orbit::Device::SELECTORS[note]
-        tmp[:index] = velocity
-        decoded[:control].merge!(tmp)
+        decoded           = decoded.merge(SurfaceMaster::Orbit::Device::SELECTORS[note])
+        decoded[:control] = { button: velocity }
+        decoded
+      end
+
+      def decode_accelerometer(decoded, _note, velocity)
+        decoded[:value] = velocity
         decoded
       end
 
       def enrich_decoded_message(decoded, note, velocity, timestamp)
         case decoded[:type]
-        when :shoulder  then decoded = decode_shoulder(decoded, note, velocity)
-        when :pad       then decoded = decode_pad(decoded, note, velocity)
-        when :knob      then decoded = decode_knob(decoded, note, velocity)
-        when :control   then decoded = decode_control(decoded, note, velocity)
+        when :shoulder      then decoded = decode_shoulder(decoded, note, velocity)
+        when :pad           then decoded = decode_pad(decoded, note, velocity)
+        when :vknob         then decoded = decode_knob(decoded, note, velocity)
+        when :accelerometer then decoded = decode_accelerometer(decoded, note, velocity)
+        else decoded = decode_control(decoded, note, velocity)
         end
         decoded[:timestamp] = timestamp
         decoded
       end
 
       def decode_input(input)
-# puts [input[:code].to_hex, input[:note].to_hex, input[:velocity].to_hex].join(" ")
         note      = input[:note]
         velocity  = input[:velocity]
         code_high = input[:code] & 0xF0
         code_low  = input[:code] & 0x0F
         raw       = SurfaceMaster::Orbit::Device::CONTROLS[code_high]
         raw       = raw[code_low] if raw
-        raw       = enrich_decoded_message(raw, note, velocity, input[:timestamp]) if raw
+        raw       = enrich_decoded_message(raw.dup, note, velocity, input[:timestamp]) if raw
         raw
       end
     end

data/lib/surface_master/orbit/interaction.rb

@@ -7,24 +7,74 @@ module SurfaceMaster
         super(opts)
       end
 
-    private
+    protected
 
+      def combined_types(type, opts = nil)
+        tmp = case type
+              when :shoulder
+                [:"#{type}-#{opts[:button]}"]
+              when :accelerometer
+                [:"#{type}-#{opts[:axis]}"]
+              when :vknob
+                knobs = opts[:vknob].nil? ? [1..4] : [opts[:vknob]]
+                banks = opts[:bank].nil? ? [1..4] : [opts[:bank]]
+
+                expand(knobs).product(expand(banks)).map { |k, b| :"#{type}-#{k}-#{b}" }
+              when :vknobs, :banks
+                buttons = opts[:button].nil? ? [1..4] : [opts[:button]]
+
+                expand(buttons).map { |b| [:"#{type}-#{b}"] }
+              when :pad
+                banks   = opts[:bank].nil? ? [1..4] : [opts[:bank]]
+                buttons = opts[:button].nil? ? [1..16] : [opts[:button]]
+
+                expand(buttons).product(expand(banks)).map { |p, b| :"#{type}-#{p}-#{b}" }
+              else
+                [type]
+              end
+        tmp.flatten.compact
+      end
+
+      def responses_hash
+        { down:   [],
+          up:     [],
+          update: [],
+          tilt:   [] }
+      end
+
+      def responses
+        @responses ||= Hash.new { |hash, key| hash[key] = responses_hash }
+      end
+
+      # TODO: Allow catching ranges of pads...
+      #
+      # TODO: Allow differentiating on bank/vknob/shoulder button...
       def respond_to_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]
-        # end
-        # actions += responses[type][state]
-        # actions += responses[:all][state]
-        # actions.compact.each {|block| block.call(self, 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)
+        combined_types  = combined_types(action[:type].to_sym, action[:control])
+        state           = action[:state].to_sym
+        actions         = []
+        actions        += combined_types.map { |ct| responses[ct][state] }
+        actions        += responses[:all][state]
+        actions.flatten.compact
+      end
+
+      def expand_states(state)
+        case state
+        when :both  then %i(down up)
+        when :all   then responses_hash.keys
+        else Array(state)
+        end
+      end
     end
   end
 end

data/lib/surface_master/orbit/midi_codes.rb

@@ -6,28 +6,28 @@ module SurfaceMaster
     module MIDICodes
       # TODO: Use a lib to do a deep-freeze.
       # rubocop:disable Metrics/LineLength
-      CONTROLS    = { 0x90 => { 0x00 => { type: :pad,           action: :down,    control: { bank: 1 } },
-                                0x01 => { type: :pad,           action: :down,    control: { bank: 2 } },
-                                0x02 => { type: :pad,           action: :down,    control: { bank: 3 } },
-                                0x03 => { type: :pad,           action: :down,    control: { bank: 4 } },
-                                0x0F => { type: :shoulder,      action: :down,    control: {} } },
-                      0x80 => { 0x00 => { type: :pad,           action: :up,      control: { bank: 1 } },
-                                0x01 => { type: :pad,           action: :up,      control: { bank: 2 } },
-                                0x02 => { type: :pad,           action: :up,      control: { bank: 3 } },
-                                0x03 => { type: :pad,           action: :up,      control: { bank: 4 } },
-                                0x0F => { type: :shoulder,      action: :up,      control: {} } },
-                      0xB0 => { 0x00 => { type: :knob,          action: :update,  control: { vknob: 1 } },
-                                0x01 => { type: :knob,          action: :update,  control: { vknob: 2 } },
-                                0x02 => { type: :knob,          action: :update,  control: { vknob: 3 } },
-                                0x03 => { type: :knob,          action: :update,  control: { vknob: 4 } },
-                                0x0C => { type: :accelerometer, action: :tilt,    control: { axis: :x } },
-                                0x0D => { type: :accelerometer, action: :tilt,    control: { axis: :y } },
-                                0x0F => { type: :control,       action: :switch,  control: {} } } }.freeze
+      CONTROLS    = { 0x90 => { 0x00 => { type: :pad,           state: :down,    control: { bank: 1 } },
+                                0x01 => { type: :pad,           state: :down,    control: { bank: 2 } },
+                                0x02 => { type: :pad,           state: :down,    control: { bank: 3 } },
+                                0x03 => { type: :pad,           state: :down,    control: { bank: 4 } },
+                                0x0F => { type: :shoulder,      state: :down,    control: {} } },
+                      0x80 => { 0x00 => { type: :pad,           state: :up,      control: { bank: 1 } },
+                                0x01 => { type: :pad,           state: :up,      control: { bank: 2 } },
+                                0x02 => { type: :pad,           state: :up,      control: { bank: 3 } },
+                                0x03 => { type: :pad,           state: :up,      control: { bank: 4 } },
+                                0x0F => { type: :shoulder,      state: :up,      control: {} } },
+                      0xB0 => { 0x00 => { type: :vknob,         state: :update,  control: { vknob: 1 } },
+                                0x01 => { type: :vknob,         state: :update,  control: { vknob: 2 } },
+                                0x02 => { type: :vknob,         state: :update,  control: { vknob: 3 } },
+                                0x03 => { type: :vknob,         state: :update,  control: { vknob: 4 } },
+                                0x0C => { type: :accelerometer, state: :tilt,    control: { axis: :x } },
+                                0x0D => { type: :accelerometer, state: :tilt,    control: { axis: :y } },
+                                0x0F => {                       state: :down } } }.freeze
       # rubocop:enable Metrics/LineLength
       SHOULDERS   = { 0x03 => { button: :left },
                       0x04 => { button: :right } }.freeze
-      SELECTORS   = { 0x01 => { selector: :banks },
-                      0x02 => { selector: :vknobs } }.freeze
+      SELECTORS   = { 0x01 => { type:   :banks },
+                      0x02 => { type:   :vknobs } }.freeze
     end
   end
 end

data/lib/surface_master/version.rb

@@ -1,4 +1,4 @@
 #
 module SurfaceMaster
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

data/lib/surface_master.rb

@@ -24,3 +24,4 @@ require "surface_master/launchpad/interaction"
 
 require "surface_master/orbit/midi_codes"
 require "surface_master/orbit/device"
+require "surface_master/orbit/interaction"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surface_master
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Jon Frisby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-09 00:00:00.000000000 Z
+date: 2015-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: portmidi
@@ -73,9 +73,11 @@ files:
 - debug_tools/decode.rb
 - debug_tools/extract_midi_monitor_sample.sh
 - docs/Numark_Orbit_QuickRef.md
-- examples/launchpad_testbed.rb
-- examples/monitor.rb
-- examples/orbit_testbed.rb
+- examples/launchpad_playground.rb
+- examples/orbit_device.rb
+- examples/orbit_interaction.rb
+- examples/orbit_playground.rb
+- examples/system_monitor.rb
 - lib/surface_master.rb
 - lib/surface_master/device.rb
 - lib/surface_master/errors.rb