surface_master 0.2.0

data/debug_tools/decode.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+fname = ARGV.shift
+raise "Must specify filename." unless fname
+outname = fname.gsub(/\.raw/, ".txt")
+
+bytes   = File.read(fname).bytes.map { |x| "0x%02X" % x }
+output = [bytes.shift(5).join(", ")] # SysEx vendor header...
+
+output << bytes.shift(2).join(", ") # Apparent prefix...
+while (row = bytes.shift(3).join(", ")) != ""
+  output << row
+end
+
+File.write(outname, output.join("\n") + "\n")

data/debug_tools/extract_midi_monitor_sample.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+FNAME=${1:-}
+
+if [[ $FNAME == "" ]]; then
+  echo "Usage: extract_midi_monitor_sample.sh <save_file.mmon>"
+  exit 1
+fi
+
+plutil -convert xml1 $FNAME
+
+xpath $FNAME "//dict/data" 2>/dev/null |
+  grep -v -E '(^<data>)|(</data>$)' |
+  base64 -D |
+  plutil -convert xml1 - -o - > ${FNAME%.mmon}.tmp
+
+# Not sure we're guaranteed to get the same number of elements every time,
+# so the `5` below may be brittle!
+xpath ${FNAME%.mmon}.tmp "//dict/array/dict[5]/data" 2>/dev/null |
+  grep -v -E '(^<data>)|(</data>$)' |
+  base64 -D > ${FNAME%.mmon}.1.raw
+
+xpath ${FNAME%.mmon}.tmp "//dict/array/dict[9]/data" 2>/dev/null |
+  grep -v -E '(^<data>)|(</data>$)' |
+  base64 -D > ${FNAME%.mmon}.2.raw
+
+xpath ${FNAME%.mmon}.tmp "//dict/array/dict[11]/data" 2>/dev/null |
+  grep -v -E '(^<data>)|(</data>$)' |
+  base64 -D > ${FNAME%.mmon}.3.raw
+
+rm ${FNAME%.mmon}.tmp

data/docs/Numark_Orbit_QuickRef.md

@@ -0,0 +1,50 @@
+# Numark Orbit Quick Reference
+
+## Low Battery Indicator
+
+Any blinking `Pad Bank Selectors` indicates the battery is low.
+
+
+## Check Battery Level
+
+Hold down `Virtual Knob Selector` `K1` for several seconds.  `Pad Bank Selectors` will light up to indicate charge level.
+
+
+## Reset Lights
+
+1. Turn Orbit off.
+1. Press and hold `Pad Bank Selectors` `1` and `4`.
+1. Turn Orbit on.
+1. Press the upper-left-most pad.
+
+
+## Pairing
+
+1. Turn Orbit off, and unplug USB adapter.
+1. Press and hold `Pad Bank Selectors` `1` and `4`.
+1. Turn Orbit on.
+1. Press the lower-right-most pad.
+1. Connect the USB adapter __within 10 seconds__.
+1. Press the pad __above__ the lower-right-most pad.
+1. The `Virtual Knob Selectors` will flash once to indicate successful pairing.
+
+
+## Sleep Mode
+
+Sleep mode will activate after 3 minutes of inactivity.  Move the Orbit to wake it up.
+
+
+## Wireless Concerns.
+
+* 100 ft maximum distance with line of sight.
+* 2.4Ghz frequency spectrum (turn off wifi/etc for best results).
+
+
+## Hard Reset
+
+1. Turn Orbit off, and unplug USB adapter.
+1. Press and hold `Pad Bank Selectors` `1` and `4`.
+1. Turn Orbit on.
+1. Press the upper-left-most pad.
+1. Press the pad to the right of the upper-left-most pad.
+1. Turn Orbit off, and back on.

data/examples/launchpad_testbed.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+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
+TIME_SCALE  = 4.0
+
+# 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 }
+
+def clamp(val); (val > 0x3F) ? 0x3F : val; end
+
+def base_color(x, y)
+  return nil if PRESSED[x][y]
+  quad_x  = x / 4
+  quad_y  = 1 - (y / 4)
+  quad    = QUADRANTS[quad_y][quad_x]
+  s_t     = (Math.sin(NOW[0] * TIME_SCALE) * 0.5) + 0.5
+  tmp     = { red:    0x00        + quad[:red] + (s_t * 0x3F).round,
+              green:  (x * SCALE) + quad[:green],
+              blue:   (y * SCALE) + quad[:blue] }
+  if FLIPPED[quad_y][quad_x]
+    carry       = tmp[:red]
+    tmp[:red]   = tmp[:green]
+    tmp[:green] = tmp[:blue]
+    tmp[:blue]  = carry
+  end
+  { red:    clamp(tmp[:red]),
+    green:  clamp(tmp[:green]),
+    blue:   clamp(tmp[:blue]) }
+end
+
+def init_board(interaction)
+  values = GRID.map do |value|
+    tmp = base_color(*value[:grid])
+    next unless tmp
+    value.merge(tmp)
+  end
+  interaction.changes(values.compact)
+end
+
+def set_grid_rgb(interaction, red:, green:, blue: )
+  values = GRID.map { |value| value.merge(red: red, green: green, blue: blue) }
+  interaction.changes(values)
+end
+
+def goodbye(interaction)
+  interaction.changes([{ red: 0x00, green: 0x00, blue: 0x00, cc: :mixer },
+                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene1 },
+                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene2 },
+                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene3 },
+                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene4 }])
+  (0..63).step(2).each do |i|
+    ii = (63 - i) - 1
+    set_grid_rgb(interaction, red: ii, green: 0x00, blue: ii)
+    sleep 0.01
+  end
+  interaction.close
+end
+
+SurfaceMaster.init!
+interaction = SurfaceMaster::Launchpad::Interaction.new
+interaction.response_to(:grid) do |inter, action|
+  x = action[:x]
+  y = action[:y]
+  PRESSED[x][y] = (action[:state] == :down)
+  value         = base_color(x, y) || WHITE
+  value[:grid]  = [x, y]
+  inter.change(value)
+end
+
+def flip_quad!(inter, cc, quad_x, quad_y)
+  FLIPPED[quad_y][quad_x]   = !FLIPPED[quad_y][quad_x]
+  if FLIPPED[quad_y][quad_x]
+    color = { red: 0x1F, green: 0x1F, blue: 0x1F }
+  else
+    color = { red: 0x03, green: 0x03, blue: 0x03 }
+  end
+  inter.change(color.merge(cc: cc))
+end
+
+interaction.response_to(:scene1, :down) do |inter, action|
+  flip_quad!(inter, action[:type], 0, 0)
+end
+interaction.response_to(:scene2, :down) do |inter, action|
+  flip_quad!(inter, action[:type], 1, 0)
+end
+interaction.response_to(:scene3, :down) do |inter, action|
+  flip_quad!(inter, action[:type], 0, 1)
+end
+interaction.response_to(:scene4, :down) do |inter, action|
+  flip_quad!(inter, action[:type], 1, 1)
+end
+
+interaction.response_to(:mixer, :down) do |_interaction, action|
+  interaction.stop
+end
+interaction.change({ red: 0x03, green: 0x00, blue: 0x00, cc: :mixer })
+interaction.changes(%i(scene1 scene2 scene3 scene4).map { |cc| { red: 0x03, green: 0x03, blue: 0x03, cc: cc } })
+
+init_board(interaction)
+input_thread = Thread.new do
+  interaction.start
+end
+animation_thread = Thread.new do
+  loop do
+    begin
+      NOW[0] = Time.now.to_f
+      init_board(interaction)
+    rescue Exception => e
+      puts e.inspect
+      puts e.backtrace.join("\n")
+    end
+    sleep 0.01
+  end
+end
+
+input_thread.join
+animation_thread.terminate
+goodbye(interaction)

data/examples/monitor.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# require "bignum"
+require "rubygems"
+require "bundler/setup"
+Bundler.require(:default, :development)
+
+require "surface_master"
+
+def goodbye(interaction)
+  data = []
+  (0..7).each do |x|
+    (0..7).each do |y|
+      data << { x: x, y: y, red: 0x00, green: 0x00, blue: 0x00 }
+    end
+  end
+  interaction.changes(data)
+end
+
+def bar(interaction, x, val, r, g, b)
+  data = []
+  (0..val).each do |y|
+    data << { x: x, y: y, red: r, green: g, blue: b }
+  end
+  ((val+1)..7).each do |y|
+    data << { x: x, y: y, red: 0x00, green: 0x00, blue: 0x00 }
+  end
+  interaction.changes(data)
+end
+
+interaction = SurfaceMaster::Launchpad::Interaction.new
+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_usage  = ((disk_pct / 100.0) * 8.0).round.to_i
+
+    puts "I/O=#{disk_pct}%, CPU=#{cpu_pct}%"
+
+    # TODO: Network in/out...
+
+    # TODO: Make block I/O not be a bar but a fill, with scale indicated by color...
+
+    bar(interaction, 0, cpu_usage, 0x3F, 0x00, 0x00)
+    bar(interaction, 1, disk_usage, 0x00, 0x3F, 0x00)
+  end
+end
+
+interaction.response_to(:mixer, :down) do |_interaction, action|
+  puts "Shutting down"
+  begin
+    monitor.kill
+    goodbye(interaction)
+    interaction.stop
+  rescue Exception => e
+    puts e.inspect
+  end
+end
+interaction.start

data/examples/orbit_testbed.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# require "bignum"
+require "rubygems"
+require "bundler/setup"
+Bundler.require(:default, :development)
+
+require "surface_master"
+
+class Fixnum
+  def to_hex; "%02X" % self; end
+end
+
+# def debug(msg)
+#   STDERR.puts "DEBUG: #{msg}"
+# end
+
+# def fmt_message(message)
+#   message[:raw][:message].map(&:to_hex).join(' ')
+# end
+
+SurfaceMaster.init!
+device = SurfaceMaster::Orbit::Device.new
+loop do
+  device.read.each do |input|
+    puts input.inspect
+  end
+  sleep 0.1
+end
+
+# interaction = ControlCenter::Launchpad::Interaction.new
+# interaction.response_to(:grid) do |inter, action|
+#   x = action[:x]
+#   y = action[:y]
+#   PRESSED[x][y] = (action[:state] == :down)
+#   value         = base_color(x, y) || WHITE
+#   value[:grid]  = [x, y]
+#   inter.device.change(value)
+# end
+
+# interaction.device.change({ red: 0x03, green: 0x00, blue: 0x00, cc: :mixer })
+# interaction.device.changes(%i(scene1 scene2 scene3 scene4).map { |cc| { red: 0x03, green: 0x03, blue: 0x03, cc: cc } })
+
+# init_board(interaction)
+# input_thread = Thread.new do
+#   interaction.start
+# end
+# animation_thread = Thread.new do
+#   loop do
+#     begin
+#       NOW[0] = Time.now.to_f
+#       init_board(interaction)
+#     rescue Exception => e
+#       puts e.inspect
+#       puts e.backtrace.join("\n")
+#     end
+#     sleep 0.01
+#   end
+# end
+
+# input_thread.join
+# animation_thread.terminate
+# goodbye(interaction)

data/lib/control_center.rb

@@ -0,0 +1,26 @@
+require "portmidi"
+require "logger"
+
+# APIs to enable access to various MIDI-based control surfaces.
+module SurfaceMaster
+  def self.init!
+    @initialized ||= begin
+      Portmidi.start
+      true
+    end
+  end
+end
+
+require "surface_master/version"
+require "surface_master/errors"
+require "surface_master/logging"
+require "surface_master/device"
+require "surface_master/interaction"
+
+require "surface_master/launchpad/errors"
+require "surface_master/launchpad/midi_codes"
+require "surface_master/launchpad/device"
+require "surface_master/launchpad/interaction"
+
+require "surface_master/orbit/midi_codes"
+require "surface_master/orbit/device"

data/lib/surface_master/device.rb

@@ -0,0 +1,90 @@
+module SurfaceMaster
+  # Base class for MIDI controller drivers.
+  #
+  # Sub-classes should extend the constructor, extend `sysex_prefix`, implement `reset!`, and add
+  # whatever methods are appropriate for them.
+  class Device
+    include Logging
+
+    def initialize(opts = nil)
+      opts  = { input:  true,
+                output: true }
+              .merge(opts || {})
+
+      self.logger = opts[:logger]
+      logger.debug "Initializing #{self.class}##{object_id} with #{opts.inspect}"
+
+      @input    = create_device!(Portmidi.input_devices,
+                                 Portmidi::Input,
+                                 id:   opts[:input_device_id],
+                                 name: opts[:device_name]) if opts[:input]
+      @output   = create_device!(Portmidi.output_devices,
+                                 Portmidi::Output,
+                                 id:   opts[:output_device_id],
+                                 name: opts[:device_name]) if opts[:output]
+    end
+
+    # Closes the device - nothing can be done with the device afterwards.
+    def close
+      logger.debug "Closing #{self.class}##{object_id}"
+      @input.close unless @input.nil?
+      @input = nil
+      @output.close unless @output.nil?
+      @output = nil
+    end
+
+    def closed?; !(input_enabled? || output_enabled?); end
+    def input_enabled?; !@input.nil?; end
+    def output_enabled?; !@output.nil?; end
+
+    def reset!; end
+
+    def read
+      unless input_enabled?
+        logger.error "Trying to read from device that's not been initialized for input!"
+        raise SurfaceMaster::NoInputAllowedError
+      end
+
+      Array(@input.read(16)).collect do |midi_message|
+        (code, note, velocity) = midi_message[:message]
+        { timestamp:  midi_message[:timestamp],
+          state:      (velocity == 127) ? :down : :up,
+          velocity:   velocity,
+          code:       code,
+          note:       note }
+      end
+    end
+
+  protected
+
+    def sysex_prefix; [0xF0]; end
+    def sysex_suffix; 0xF7; end
+    def sysex_msg(*payload); (sysex_prefix + [payload, sysex_suffix]).flatten.compact; end
+    def sysex!(*payload)
+      msg = sysex_msg(payload)
+      logger.debug { "#{msg.length}: 0x#{msg.map(&:to_hex).join(", 0x")}" }
+      @output.write_sysex(msg)
+    end
+
+    def create_device!(devices, device_type, opts)
+      logger.debug "Creating #{device_type} with #{opts.inspect}, choosing from portmidi devices: #{devices.inspect}"
+      id = opts[:id]
+      if id.nil?
+        name    = opts[:name] || @name
+        device  = devices.select { |dev| dev.name == name }.first
+        id      = device.device_id unless device.nil?
+      end
+      if id.nil?
+        message = "MIDI Device `#{opts[:id] || opts[:name]}` doesn't exist!"
+        logger.fatal message
+        raise SurfaceMaster::NoSuchDeviceError.new(message)
+      end
+      device_type.new(id)
+    rescue RuntimeError => e # TODO: Uh, this should be StandardException, perhaps?
+      logger.fatal "Error creating #{device_type}: #{e.inspect}"
+      raise SurfaceMaster::DeviceBusyError.new(e)
+    end
+
+    def message(status, data1, data2); { message: [status, data1, data2], timestamp: 0 }; end
+  end
+end