surface_master 0.2.0

data/lib/surface_master/errors.rb

@@ -0,0 +1,27 @@
+module SurfaceMaster
+  # Unclassified error.
+  class GenericError < StandardError; end
+
+  # Error raised when the MIDI device specified doesn't exist.
+  class NoSuchDeviceError < GenericError; end
+
+  # Error raised when the MIDI device specified is busy.
+  class DeviceBusyError < GenericError; end
+
+  # Error raised when an input has been requested, although device has been initialized without
+  # input.
+  class NoInputAllowedError < GenericError; end
+
+  # Error raised when an output has been requested, although device has been initialized without
+  # output.
+  class NoOutputAllowedError < GenericError; end
+
+  # Error raised when anything fails while communicating with a device.
+  class CommunicationError < GenericError
+    attr_accessor :source
+    def initialize(e)
+      super(e.portmidi_error)
+      self.source = e
+    end
+  end
+end

data/lib/surface_master/interaction.rb

@@ -0,0 +1,133 @@
+module SurfaceMaster
+  # Base class for event-based drivers.  Sub-classes should extend the constructor, and implement `respond_to_action`
+  class Interaction
+    include Logging
+
+    attr_reader :device, :active
+
+    def initialize(opts = nil)
+      opts ||= {}
+
+      self.logger = opts[:logger]
+      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]))
+      @latency      = (opts[:latency] || 0.001).to_f.abs
+      @active       = false
+
+      @action_threads = ThreadGroup.new
+    end
+
+    def change(opts); @device.change(opts); end
+    def changes(opts); @device.changes(opts); end
+
+    def close
+      logger.debug "Closing #{self.class}##{object_id}"
+      stop
+      @device.close
+    end
+
+    def closed?; @device.closed?; end
+
+    def start(opts = nil)
+      logger.debug "Starting #{self.class}##{object_id}"
+
+      opts = { detached: false }.merge(opts || {})
+
+      @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
+
+    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
+      @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
+      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
+      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
+      # TODO: Generalize for arbitrary actions...
+      @responses ||= Hash.new { |hash, key| hash[key] = { down: [], up: [] } }
+    end
+
+    def respond_to_action(action); end
+  end
+end

data/lib/surface_master/launchpad/device.rb

@@ -0,0 +1,159 @@
+module SurfaceMaster
+  module Launchpad
+    class Device < SurfaceMaster::Device
+      include MIDICodes
+
+      # TODO: Rename scenes to match Mk2
+      CODE_NOTE_TO_TYPE = Hash.new { |*_| :grid }
+                          .merge([Status::ON, Scene::SCENE1]     => :scene1,
+                                 [Status::ON, Scene::SCENE2]     => :scene2,
+                                 [Status::ON, Scene::SCENE3]     => :scene3,
+                                 [Status::ON, Scene::SCENE4]     => :scene4,
+                                 [Status::ON, Scene::SCENE5]     => :scene5,
+                                 [Status::ON, Scene::SCENE6]     => :scene6,
+                                 [Status::ON, Scene::SCENE7]     => :scene7,
+                                 [Status::ON, Scene::SCENE8]     => :scene8,
+                                 [Status::CC, Control::UP]       => :up,
+                                 [Status::CC, Control::DOWN]     => :down,
+                                 [Status::CC, Control::LEFT]     => :left,
+                                 [Status::CC, Control::RIGHT]    => :right,
+                                 [Status::CC, Control::SESSION]  => :session,
+                                 [Status::CC, Control::USER1]    => :user1,
+                                 [Status::CC, Control::USER2]    => :user2,
+                                 [Status::CC, Control::MIXER]    => :mixer)
+                          .freeze
+      TYPE_TO_NOTE      = { up:      Control::UP,
+                            down:    Control::DOWN,
+                            left:    Control::LEFT,
+                            right:   Control::RIGHT,
+                            session: Control::SESSION,
+                            user1:   Control::USER1,
+                            user2:   Control::USER2,
+                            mixer:   Control::MIXER,
+                            scene1:  Scene::SCENE1, # Volume
+                            scene2:  Scene::SCENE2, # Pan
+                            scene3:  Scene::SCENE3, # Send A
+                            scene4:  Scene::SCENE4, # Send B
+                            scene5:  Scene::SCENE5, # Stop
+                            scene6:  Scene::SCENE6, # Mute
+                            scene7:  Scene::SCENE7, # Solo
+                            scene8:  Scene::SCENE8 }.freeze # Record Arm
+
+      def initialize(opts = nil)
+        @name = "Launchpad MK2"
+        super(opts)
+        reset! if output_enabled?
+      end
+
+      def reset
+        # TODO: Suss out what this should be for the Mark 2.
+        layout!(0x00)
+        output!(Status::CC, Status::NIL, Status::NIL)
+      end
+
+      # TODO: Support more of the LaunchPad Mark 2's functionality.
+
+      def change(opts = nil)
+        opts ||= {}
+        command, payload = color_payload(opts)
+        sysex!(command, payload[:led], payload[:color])
+      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.
+          while (slice = payloads.shift(62)).length > 0
+            sysex!(command, *slice.map { |payload| [payload[:led], payload[:color]] })
+          end
+        end
+      end
+
+      def read
+        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
+          input
+        end
+      end
+
+    protected
+
+      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]]
+        end
+      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
+        end
+        [command, { led: led, color: color }]
+      end
+
+      def output!(status, data1, data2)
+        outputs!(message(status, data1, data2))
+      end
+
+      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
+        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

@@ -0,0 +1,11 @@
+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
+end

data/lib/surface_master/launchpad/interaction.rb

@@ -0,0 +1,86 @@
+module SurfaceMaster
+  module Launchpad
+    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
+        @responses ||= Hash.new { |hash, key| hash[key] = { down: [], up: [] } }
+      end
+
+      def grid_range(range)
+        return nil if range.nil?
+        Array(range).flatten.map do |pos|
+          pos.respond_to?(:to_a) ? pos.to_a : pos
+        end.flatten.uniq
+      end
+
+      def combined_types(type, opts = nil)
+        if type.to_sym == :grid && opts
+          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.product(y).map { |xx, yy| :"grid#{xx}#{yy}" }
+        else
+          [type.to_sym]
+        end
+      end
+
+      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)}
+        nil
+      rescue Exception => e # TODO: StandardException, RuntimeError, or Exception?
+        logger.error "Error when responding to action #{action.inspect}: #{e.inspect}"
+        raise e
+      end
+    end
+  end
+end

data/lib/surface_master/launchpad/midi_codes.rb

@@ -0,0 +1,51 @@
+module SurfaceMaster
+  module Launchpad
+    module MIDICodes
+      # Module defining MIDI status codes.
+      # TODO: Some of these are fairly generic?  Can we hoist them?
+      module Status
+        NIL           = 0x00
+        OFF           = 0x80
+        ON            = 0x90
+        MULTI         = 0x92
+        CC            = 0xB0
+      end
+
+      # Module defininig MIDI data 1 (note) codes for control buttons.
+      module Control
+        UP            = 0x68
+        DOWN          = 0x69
+        LEFT          = 0x6A
+        RIGHT         = 0x6B
+        SESSION       = 0x6C
+        USER1         = 0x6D
+        USER2         = 0x6E
+        MIXER         = 0x6F
+      end
+
+      # Module defininig MIDI data 1 (note) codes for scene buttons.
+      # TODO: Rename to match Mk2...
+      module Scene
+        SCENE1        = 0x59
+        SCENE2        = 0x4f
+        SCENE3        = 0x45
+        SCENE4        = 0x3b
+        SCENE5        = 0x31
+        SCENE6        = 0x27
+        SCENE7        = 0x1d
+        SCENE8        = 0x13
+      end
+
+      # Module defining MIDI data 2 (velocity) codes.
+      module Velocity
+        TEST_LEDS     = 0x7C
+      end
+
+      # Module defining MIDI data 2 codes for selecting the grid layout.
+      module GridLayout
+        XY            = 0x01
+        DRUM_RACK     = 0x02
+      end
+    end
+  end
+end