sparkle_motion 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bbef0303576ccb86e06cecb1cf2be03219822d74
+  data.tar.gz: 6b94c6225bff6d537328dbbe1381c2d8014bc048
+SHA512:
+  metadata.gz: cc7c4cce004cb6b4f4a4b116f345e13123fa42322ad3e21e3ea813cde541995d1fbb58906449e04237056d750f07ac92655fd477a4e66d18e7e9aaadde7b024e
+  data.tar.gz: b561b42d6323c11c4fc7a878fe2a05e30ba51e32483b3977f1d85e02647f25d41555291453059cd997fda48b472b5206baadb12786a2d2335cf37b480057dd6e

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changes
+
+## Next
+
+## 0.1.0 - 2015-09-12
+
+* Initial release.  Totally undocumented, annoyingly hard-coded, etc.

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jon Frisby, http://MrJoy.com
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Sparkle Motion
+
+Generative event lighting system using Philips Hue and Novation Launchpad.
+
+
+## Installation
+
+After cloning this repo, run:
+
+```bash
+brew install portmidi
+gem install sparkle_motion
+sm-discover # Find all available bridges using SSDP.
+# Create `config.yml`, and register the username(s) in it with the relevant bridges.
+# You probably want to start with the one in this project's source repo as a baseline.
+sm-mark-lights # Ensure your lights are physically arranged properly.
+sm-on # Switch all the lights on, and set color to expected base state.
+sparkle-motion # Run the simulation.
+```
+
+__TODO: Document how to register user with hub(s).__
+
+
+## Usage
+
+* `bin/sm-discover`: Discover all Philips Hue bridges on your network.
+* `bin/sm-mark-lights`: Mark the lights distinctively to help ensure they're physically arranged properly.
+* `bin/sm-off`: Turn all configured lights off.
+* `bin/sm-on`: Turn all configured lights on, and set them to the base color.
+* `bin/sm-simulate`: Run the effect system directly.  You probably want `sparkle-motion` instead.
+* `bin/sparkle-motion`: Runs the effect system with configuration settings for debugging, and restarts it if the kick-in-the-head button is pressed.  See source for details.
+
+## Using the Code
+
+* `examples/tictactoe.rb`: A simple example of the Novation Launchpad widgets, and how to use/extend them.
+* `tools/chunker.rb`: Helper for churning through `*.raw` files and preparing them for visualization.
+* `tools/color_scale.rb`: A small playground for defining color schemes for Novation LaunchPad widgets.
+
+
+## Debugging
+
+* `bin/sm-watch-memory`: External monitor to keep an eye on the process size of `sm-simulate`.  Useful for debugging memory allocations and GC pressure.
+
+
+## Configuration
+
+__ TODO: Write me.__

data/bin/sm-discover

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+###############################################################################
+# Early Initialization/Helpers
+###############################################################################
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sparkle_motion"
+SparkleMotion.init!("discover")
+SparkleMotion.use_hue!(discovery: true)
+
+def ip_atob(ip)
+  ip.split(/\./).map(&:to_i).pack("C4")
+end
+
+# TODO: Show MAC address so we can map the IPs to bridges sanely!
+results = SparkleMotion::Hue::SSDP.new.scan
+puts results.values.sort { |a, b| ip_atob(a) <=> ip_atob(b) }.join("\n")

data/bin/sm-mark-lights

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+###############################################################################
+# Early Initialization/Helpers
+###############################################################################
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sparkle_motion"
+SparkleMotion.init!("mark_lights")
+SparkleMotion.use_hue!(api: true)
+LOGGER = SparkleMotion.logger
+
+###############################################################################
+# Main Logic
+###############################################################################
+# TODO: Use Novation Launchpad to be able to toggle lights.
+def light_state(hue, index, num_lights)
+  target      = (254 * (index / num_lights.to_f)).round
+  data        = { "on" => true,
+                  "hue" => hue,
+                  "sat" => target,
+                  "bri" => target }
+  with_transition_time(data, 0)
+end
+
+# TODO: Speed this up by setting on/hue via group message per bridge...
+%w(main_lights dance_lights accent_lights).each do |group_name|
+  config      = SparkleMotion::LightConfig.new(config: CONFIG, group: group_name)
+  url_req_map = {}
+  config.bridges.each do |bridge_name, bridge|
+    light_ids   = config.lights[bridge_name].map(&:last)
+    hue         = bridge["debug_hue"]
+    index       = 0
+    num_lights  = light_ids.length
+    requests    = light_ids
+                  .map do |lid|
+                    url               = hue_light_endpoint(bridge, lid)
+                    color             = light_state(hue, index, num_lights)
+                    index            += 1
+                    url_req_map[url]  = SparkleMotion::LazyRequestConfig.new(LOGGER, bridge, url) do
+                      color
+                    end
+                  end
+
+    next unless requests.length > 0
+    while requests.length > 0
+      retry_queue = []
+      Curl::Multi.http(requests, MULTI_OPTIONS) do |easy|
+        if easy.response_code != 200 ||
+           easy.body =~ /error/
+          url = easy.url
+          LOGGER.error { "#{url} => #{easy.response_code} / #{easy.body}" }
+          retry_queue << url
+        end
+      end
+      requests = retry_queue.map { |url| url_req_map[url] }
+    end
+  end
+end

data/bin/sm-off

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+###############################################################################
+# Early Initialization/Helpers
+###############################################################################
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sparkle_motion"
+SparkleMotion.init!("off")
+SparkleMotion.use_hue!(api: true)
+
+###############################################################################
+# Helper Functions
+###############################################################################
+def make_req_struct(url, data)
+  { method:   :put,
+    url:      url,
+    put_data: Oj.dump(data) }.merge(EASY_OPTIONS)
+end
+
+def hue_init(config)
+  make_req_struct(hue_group_endpoint(config, 0), "on" => false)
+end
+
+###############################################################################
+# Main
+###############################################################################
+# TODO: Hoist this into a separate script.
+# debug "Initializing lights..."
+init_reqs = CONFIG["bridges"]
+            .values
+            .map { |config| hue_init(config) }
+Curl::Multi.http(init_reqs, MULTI_OPTIONS) do |easy|
+  if easy.response_code != 200
+    SparkleMotion.logger.error { "Failed to initialize light: #{easy.url}" }
+    add(easy)
+  end
+end

data/bin/sm-on

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+###############################################################################
+# Early Initialization/Helpers
+###############################################################################
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sparkle_motion"
+SparkleMotion.init!("on")
+SparkleMotion.use_hue!(api: true)
+
+###############################################################################
+# Effect
+#
+# Tweak this to change the visual effect.
+###############################################################################
+INIT_HUE      = env_int("INIT_HUE", true) || 49_500
+INIT_SAT      = env_int("INIT_SAT", true) || 254
+INIT_BRI      = env_int("INIT_BRI", true) || 127
+
+###############################################################################
+# Helper Functions
+###############################################################################
+def make_req_struct(url, data)
+  { method:   :put,
+    url:      url,
+    put_data: Oj.dump(data) }.merge(EASY_OPTIONS)
+end
+
+def hue_init(config)
+  make_req_struct(hue_group_endpoint(config, 0), "on"  => true,
+                                                 "bri" => INIT_BRI,
+                                                 "sat" => INIT_SAT,
+                                                 "hue" => INIT_HUE)
+end
+
+###############################################################################
+# Main
+###############################################################################
+# TODO: Hoist this into a separate script.
+# debug "Initializing lights..."
+init_reqs = CONFIG["bridges"]
+            .values
+            .map { |config| hue_init(config) }
+Curl::Multi.http(init_reqs, MULTI_OPTIONS) do |easy|
+  if easy.response_code != 200
+    SparkleMotion.logger.error { "Failed to initialize light: #{easy.url}" }
+    add(easy)
+  end
+end

data/bin/sm-simulate

@@ -0,0 +1,595 @@
+#!/usr/bin/env ruby
+# def bench_init!; @first_time = @last_time = Time.now.to_f; end
+
+# def bench_snap!(depth = 0)
+#   t = Time.now.to_f
+#   elapsed = t - @last_time
+#   @last_time = t
+#   key = caller[depth].split(":")[0..1].join(":").split("/").last
+#   key = "TOTAL" if depth > 0
+#   puts "%s => %f sec (@%f)" % [key, elapsed, t]
+# end
+
+# def bench_end!
+#   @last_time = @first_time
+#   bench_snap!(2)
+# end
+
+# TODO: Run update across nodes from back to front for simulation rather than
+# TODO: relying on a call-chain.  This should make it easy to eliminate the
+# TODO: `yield` usage and avoid associated allocations.
+
+# TODO: Tool to read journaled debug data and produce a PNG.
+
+# TODO: Deeper memory profiling to ensure this process can run for hours.
+
+# TODO: Pick four downlights for the dance floor, and treat them as a separate
+# TODO: simulation.  Consider how spotlighting and the like will be relevant to
+# TODO: them.
+
+# TODO: Node to *clamp* brightness range so we can set the absolute limits at
+# TODO: the end of the chain?  Need to consider use-cases more thoroughly.
+# TODO: May be useful for photographer!
+
+# TODO: Rename widgets to clarify that they're LaunchPad-specific, and hoist all
+# TODO: LaunchPad code into one namespace.
+
+# TODO: Hoist all Hue code into one namespace.
+
+# TODO: Possibly break out discovery / user registration into a separate gem?
+
+#   f = Fiber.new do
+#     meth(1) do
+#       Fiber.yield
+#     end
+#   end
+#   meth(2) do
+#     f.resume
+#   end
+#   f.resume
+#   p Thread.current[:name]
+
+###############################################################################
+# Early Initialization/Helpers
+###############################################################################
+bench_init! if defined?(bench_init!)
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sparkle_motion"
+
+SparkleMotion.init!("simulate")
+# We load the following unconditionally because so much plugs into the graph
+# we don't currently have a good way of decoupling things gracefully.  So all
+# USE_GRAPH=0 really means is that we don't run the simulation thread.
+SparkleMotion.use_graph!
+
+# Code loading / modular behavior configuration:
+USE_LIGHTS  = env_bool("USE_LIGHTS")
+USE_INPUT   = env_bool("USE_INPUT")
+USE_SWEEP   = env_bool("USE_SWEEP")
+USE_GRAPH   = env_bool("USE_GRAPH")
+SparkleMotion.use_hue!(api: true) if USE_LIGHTS
+SparkleMotion.use_widgets!
+SparkleMotion.use_launchpad! if USE_INPUT
+
+# Crufty common code:
+require "sparkle_motion/output"
+
+###############################################################################
+# Profiling and Debugging
+###############################################################################
+LOGGER        = SparkleMotion.logger
+profile_run   = ENV["PROFILE_RUN"]
+PROFILE_RUN   = (profile_run != "") ? profile_run : nil
+SKIP_GC       = env_bool("SKIP_GC")
+DEBUG_FLAGS   = Hash[(ENV["DEBUG_NODES"] || "")
+                     .split(/\s*,\s*/)
+                     .map(&:upcase)
+                     .map { |nn| [nn, true] }]
+
+###############################################################################
+# Shared State Setup
+###############################################################################
+# TODO: Run all simulations, and use a mixer to blend between them...
+num_lights              = CONFIG["main_lights"].length
+LIGHTS_FOR_THREADS      = SparkleMotion::LightConfig.new(config: CONFIG, group: "main_lights")
+INTERACTION             = USE_INPUT ? Launchpad::Interaction.new(use_threads: false) : nil
+INT_STATES              = []
+NODES                   = {}
+PENDING_COMMANDS        = Queue.new
+CURRENT_STATE           = {}
+STATE_FILENAME          = "/tmp/sparkle-motion.state"
+SKIP_STATE_PERSISTENCE  = [false]
+HAVE_STATE_FILE         = File.exist?(STATE_FILENAME)
+if HAVE_STATE_FILE
+  age = Time.now.to_f - File.stat(STATE_FILENAME).mtime.to_f
+  if age > 3600
+    LOGGER.warn do
+      "#{STATE_FILENAME} is #{age} seconds old!"\
+        "  This is probably not what you want, but you're the boss..."
+    end
+  end
+  CURRENT_STATE.merge!(YAML.load(File.read(STATE_FILENAME)))
+end
+
+def update_state!(key, value)
+  old_value = CURRENT_STATE[key]
+  return if old_value == value
+  CURRENT_STATE[key] = value
+  return if SKIP_STATE_PERSISTENCE[0]
+  LOGGER.debug { "Persisting control state." }
+  # TODO: Maybe keep the file open, and rewind?
+  File.open(STATE_FILENAME, "w") do |fh|
+    fh.write(CURRENT_STATE.to_yaml)
+  end
+end
+
+###############################################################################
+# Simulation Graph Configuration / Setup
+###############################################################################
+# Root nodes (don't act as modifiers on other nodes' output):
+n_cfg           = CONFIG["simulation"]["nodes"]
+p_speed         = n_cfg["perlin"]["speed"]
+NODES["PERLIN"] = SparkleMotion::Nodes::Generators::Perlin.new(lights: num_lights, speed: p_speed)
+last            = NODES["PERLIN"]
+
+# Transform nodes (act as a chain of modifiers):
+c_cfg               = n_cfg["contrast"]
+c_fun               = c_cfg["function"]
+c_iter              = c_cfg["iterations"]
+NODES["STRETCHED"]  = last = SparkleMotion::Nodes::Transforms::Contrast.new(function:   c_fun,
+                                                                            iterations: c_iter,
+                                                                            source:     last)
+# Create one control group here per "quadrant"...
+intensity_cfg = CONFIG["simulation"]["controls"]["intensity"]
+LIGHTS_FOR_THREADS.bridges.each_with_index do |(bridge_name, _bridge_config), idx|
+  mask        = LIGHTS_FOR_THREADS.masks[bridge_name]
+  int_vals    = intensity_cfg["values"]
+  last        = SparkleMotion::Nodes::Transforms::Range.new(mid_point:  int_vals[0][0],
+                                                            delta:      int_vals[0][1],
+                                                            source:     last,
+                                                            mask:       mask,
+                                                            logger:     LOGGER)
+  NODES["SHIFTED_#{idx}"] = last
+
+  int_colors      = intensity_cfg["colors"]
+  pos             = intensity_cfg["positions"][idx]
+  int_widget      = Kernel.const_get(intensity_cfg["widget"])
+  int_key         = "SHIFTED_#{idx}"
+  INT_STATES[idx] = int_widget.new(launchpad: INTERACTION,
+                                   x:         pos[0],
+                                   y:         pos[1],
+                                   size:      intensity_cfg["size"],
+                                   on:        int_colors["on"],
+                                   off:       int_colors["off"],
+                                   down:      int_colors["down"],
+                                   on_change: proc do |val|
+                                     ival = int_vals[val]
+                                     LOGGER.info { "Intensity[#{idx},#{val}]: #{ival}" }
+                                     NODES[int_key].set_range(ival[0], ival[1])
+                                     update_state!(int_key, val)
+                                   end)
+end
+
+SAT_STATES = []
+sat_cfg     = CONFIG["simulation"]["controls"]["saturation"]
+sat_len     = sat_cfg["transition"]
+sat_colors  = sat_cfg["colors"]
+sat_vals    = sat_cfg["values"]
+sat_grps    = sat_cfg["groups"]
+sat_widget  = Kernel.const_get(sat_cfg["widget"])
+sat_cfg["positions"].each_with_index do |(xx, yy), idx|
+  sat_grp_info  = sat_grps[idx]
+  sat_bridge    = CONFIG["bridges"][sat_grp_info[0]]
+  sat_group     = sat_grp_info[1]
+  sat_key       = "SAT_STATES[#{idx}]"
+  SAT_STATES << sat_widget.new(launchpad: INTERACTION,
+                               x:         xx,
+                               y:         yy,
+                               size:      sat_cfg["size"],
+                               on:        sat_colors["on"],
+                               off:       sat_colors["off"],
+                               down:      sat_colors["down"],
+                               on_change: proc do |val|
+                                 ival = sat_vals[val]
+                                 LOGGER.info { "Saturation[#{idx},#{val}]: #{ival}" }
+                                 data = with_transition_time({ "sat" => ival }, sat_len)
+                                 req  = { method:   :put,
+                                          url:      hue_group_endpoint(sat_bridge, sat_group),
+                                          put_data: Oj.dump(data) }.merge(EASY_OPTIONS)
+                                 PENDING_COMMANDS << req
+                                 update_state!(sat_key, val)
+                               end)
+end
+
+last = NODES["SPOTLIT"] = SparkleMotion::Nodes::Transforms::Spotlight.new(source: last)
+FINAL_RESULT            = last # The end node that will be rendered to the lights.
+sl_cfg                  = CONFIG["simulation"]["controls"]["spotlighting"]
+sl_colors               = sl_cfg["colors"]
+sl_map_raw              = sl_cfg["mappings"]
+sl_pos                  = sl_map_raw.flatten
+sl_key                  = "SPOTLIT"
+sl_size                 = [sl_map_raw.map(&:length).sort[-1], sl_map_raw.length]
+SL_STATE = SparkleMotion::LaunchPad::Widgets::RadioGroup.new(launchpad:   INTERACTION,
+                                                             x:           sl_cfg["x"],
+                                                             y:           sl_cfg["y"],
+                                                             size:        sl_size,
+                                                             on:          sl_colors["on"],
+                                                             off:         sl_colors["off"],
+                                                             down:        sl_colors["down"],
+                                                             on_select:   proc do |x|
+                                                               LOGGER.info { "Spot ##{sl_pos[x]}" }
+                                                               NODES[sl_key].spotlight!(sl_pos[x])
+                                                               update_state!(sl_key, x)
+                                                             end,
+                                                             on_deselect: proc do
+                                                               LOGGER.info { "Spot Off" }
+                                                               NODES["SPOTLIT"].clear!
+                                                               update_state!(sl_key, nil)
+                                                             end)
+
+NODES.each do |name, node|
+  node.debug = DEBUG_FLAGS[name]
+end
+
+###############################################################################
+# Operational Configuration
+###############################################################################
+ITERATIONS                = env_int("ITERATIONS", true) || 0
+TIME_TO_DIE               = [false, :terminate]
+
+###############################################################################
+# Profiling Support
+###############################################################################
+# TODO: Make this optional.
+e_cfg = CONFIG["simulation"]["controls"]["exit"]
+EXIT_BUTTON = SparkleMotion::LaunchPad::Widgets::Button.new(launchpad: INTERACTION,
+                                                            position:  e_cfg["position"].to_sym,
+                                                            color:     e_cfg["colors"]["color"],
+                                                            down:      e_cfg["colors"]["down"],
+                                                            on_press:  lambda do |value|
+                                                              return unless value != 0
+                                                              LOGGER.unknown { "Kick!" }
+                                                              TIME_TO_DIE[1] = :restart
+                                                              TIME_TO_DIE[0] = true
+                                                            end)
+
+def start_ruby_prof!
+  return unless PROFILE_RUN == "ruby-prof"
+
+  SparkleMotion.logger.unknown { "Enabling ruby-prof, be careful!" }
+  require "ruby-prof"
+  RubyProf.measure_mode = RubyProf.const_get(ENV.fetch("RUBY_PROF_MODE").upcase)
+  RubyProf.start
+end
+
+def stop_ruby_prof!
+  return unless PROFILE_RUN == "ruby-prof"
+
+  result  = RubyProf.stop
+  printer = RubyProf::CallStackPrinter.new(result)
+  File.open("tmp/results.html", "w") do |fh|
+    printer.print(fh)
+  end
+end
+
+###############################################################################
+# Main Simulation
+###############################################################################
+def clear_board!
+  return unless defined?(Launchpad)
+
+  # TODO: Generalize this to deal with the entire board.
+
+  # TODO: Hoist setup / teardown of the board into separate binaries and
+  # TODO: don't do it from here to avoid startup overhead!
+
+  INT_STATES.map(&:blank)
+  sleep 0.01 # 88 updates/sec input limit!
+  SAT_STATES.map(&:blank)
+  sleep 0.01 # 88 updates/sec input limit!
+  SL_STATE.blank
+  sleep 0.01
+  EXIT_BUTTON.blank
+end
+
+def any_in_state(threads, state)
+  threads = Array(threads)
+  threads.find { |th| th.status != state }
+end
+
+def wait_for(threads, state)
+  threads = Array(threads)
+  sleep 0.01 while any_in_state(threads, state)
+end
+
+def without_persistence(&block)
+  SKIP_STATE_PERSISTENCE[0] = defined?(LaunchPad) ? true : false
+  block.call
+ensure
+  SKIP_STATE_PERSISTENCE[0] = false
+end
+
+def setup_intensity_controls!
+  INT_STATES.each_with_index do |ctrl, idx|
+    ctrl.update(CURRENT_STATE.fetch("SHIFTED_#{idx}", ctrl.max_v / 2))
+  end
+end
+
+def setup_saturation_controls!
+  SAT_STATES.each_with_index do |ctrl, idx|
+    ctrl.update(CURRENT_STATE.fetch("SAT_STATES[#{idx}]", ctrl.max_v))
+  end
+end
+
+def setup_spotlight_controls!
+  SL_STATE.update(CURRENT_STATE.fetch("SPOTLIT", nil))
+end
+
+def setup_exit_controls!
+  EXIT_BUTTON.update(false)
+end
+
+def guarded_thread(name, &block)
+  Thread.new { guard_call(name, &block) }
+end
+
+def launch_input_thread!
+  without_persistence do
+    setup_intensity_controls!
+    setup_saturation_controls!
+    setup_spotlight_controls!
+    setup_exit_controls!
+  end
+  # Don't send updates from our attempts at setting things up when we're
+  # picking up where we left of...
+  PENDING_COMMANDS.clear if HAVE_STATE_FILE
+
+  return nil unless defined?(Launchpad)
+
+  guarded_thread("Input Handler") do
+    Thread.stop
+    INTERACTION.start
+  end
+end
+
+def launch_graph_thread!
+  return nil unless USE_GRAPH
+  guarded_thread("Graph Renderer") do
+    Thread.stop
+
+    loop do
+      t = Time.now.to_f
+      FINAL_RESULT.update(t)
+      el = Time.now.to_f - t
+      # Try to adhere to a specific update frequency...
+      sleep SparkleMotion::Node::FRAME_PERIOD - el if el < SparkleMotion::Node::FRAME_PERIOD
+    end
+  end
+end
+
+def add_group_command!(config, data)
+  # TODO: Hoist the hash into something reusable?
+  PENDING_COMMANDS << { method:   :put,
+                        url:      hue_group_endpoint(config, 0),
+                        put_data: Oj.dump(data) }.merge(EASY_OPTIONS)
+end
+
+def launch_sweep_thread!(sweep_cfg)
+  return nil unless USE_LIGHTS && USE_SWEEP
+  hues        = sweep_cfg["values"]
+  sweep_len   = sweep_cfg["transition"]
+  sweep_wait  = sweep_len
+  if sweep_len < 0
+    sweep_wait  = sweep_len.abs
+    sweep_len   = 0.0
+  end
+  guarded_thread("Sweeper") do
+    Thread.stop
+
+    loop do
+      before_time = Time.now.to_f
+      idx         = ((before_time / sweep_wait) % hues.length).floor
+      data        = with_transition_time({ "hue" => hues[idx] }, sweep_len)
+      CONFIG["bridges"].each do |(_name, config)|
+        add_group_command!(config, data)
+      end
+
+      elapsed = Time.now.to_f - before_time
+      sleep sweep_wait - elapsed if elapsed < sweep_wait
+    end
+  end
+end
+
+def launch_dummy_light_threads!
+  threads = []
+  threads << guarded_thread("Dummy Thread") do
+    Thread.stop
+    iters = ITERATIONS
+    iters = 20 if iters == 0
+    sleep iters * 5.0
+    TIME_TO_DIE[1] = :terminate
+    TIME_TO_DIE[0] = true
+  end
+  threads
+end
+
+def launch_light_threads!(cfg, global_results)
+  threads = []
+  return launch_dummy_light_threads! unless USE_LIGHTS
+
+  transition  = cfg["transition"]
+  debug       = DEBUG_FLAGS["OUTPUT"]
+  threads    += LIGHTS_FOR_THREADS.bridges.map do |(bridge_name, config)|
+    guarded_thread(bridge_name) do
+      lights    = LIGHTS_FOR_THREADS.lights[bridge_name]
+      stats     = defined?(Results) ? Results.new(logger: LOGGER) : nil
+      iterator  = (ITERATIONS > 0) ? ITERATIONS.times : loop
+
+      LOGGER.unknown do
+        light_list = lights.map(&:first).join(", ")
+        "#{bridge_name}: Thread set to handle #{lights.count} lights (#{light_list})."
+      end
+
+      Thread.stop
+
+      requests = lights
+                 .map do |(idx, lid)|
+                   url = hue_light_endpoint(config, lid)
+                   SparkleMotion::LazyRequestConfig.new(LOGGER, config, url, stats, debug: debug) do
+                     # TODO: Recycle this hash?
+                     data = { "bri" => (FINAL_RESULT[idx] * 254).to_i }
+                     with_transition_time(data, transition)
+                   end
+                 end
+
+      iterator.each do
+        Curl::Multi.http(requests.dup, MULTI_OPTIONS) do
+        end
+
+        global_results.add_from(stats) if global_results
+        stats.clear! if stats
+        sleep 0.1
+      end
+    end
+  end
+
+  threads << guarded_thread("Command Queue") do
+    Thread.stop
+    loop do
+      sleep 0.05 while PENDING_COMMANDS.empty?
+
+      # TODO: Gather stats about success/failure...
+      # results     = Results.new(logger: LOGGER)
+      # global_results.add_from(results)
+      # results.clear!
+
+      requests = []
+      requests << PENDING_COMMANDS.pop until PENDING_COMMANDS.empty?
+      next if requests.length == 0
+      LOGGER.debug { "Processing #{requests.length} pending commands." }
+      Curl::Multi.http(requests, MULTI_OPTIONS) do |easy|
+        rc    = easy.response_code
+        body  = easy.body
+        next if rc >= 200 && rc < 400 && body !~ /error/
+        LOGGER.warn { "Problem processing command: #{easy.url} => #{rc}; #{body}" }
+      end
+    end
+  end
+end
+
+def launch_all_threads!(sim_cfg, global_results)
+  tmp = { input:  [launch_input_thread!].compact,
+          graph:  [launch_graph_thread!].compact,
+          sweep:  [launch_sweep_thread!(sim_cfg["sweep"])].compact,
+          lights: launch_light_threads!(sim_cfg["output"], global_results) }
+  tmp[:all] = tmp.values.flatten.compact
+  tmp
+end
+
+def pre_init!
+  trap("INT") do
+    TIME_TO_DIE[0] = true
+    # If we hit ctrl-c, it'll show up on the terminal, mucking with log output right when we're
+    # about to produce reports.  This annoys me, so I'm working around it:
+    puts
+  end
+  Thread.abort_on_exception = false
+end
+
+def nodes_under_debug
+  NODES.select { |name, _node| DEBUG_FLAGS[name] }
+end
+
+def debugging?
+  nodes_under_debug.length > 0 || DEBUG_FLAGS["OUTPUT"] || PROFILE_RUN
+end
+
+def wait_for_threads!(threads)
+  LOGGER.unknown { "Waiting for threads to finish initializing..." }
+  wait_for(threads, "sleep")
+end
+
+def init!(global_results)
+  LOGGER.unknown { "Initializing system..." }
+  if SKIP_GC
+    LOGGER.unknown { "Disabling garbage collection!  BE CAREFUL!" }
+    GC.disable
+  end
+  global_results.begin! if global_results
+  start_ruby_prof!
+  FINAL_RESULT.update(Time.now.to_f)
+end
+
+def wake!(threads)
+  LOGGER.unknown { "Final setup done, waking threads..." }
+  threads.each(&:run)
+end
+
+def spin!(threads)
+  LOGGER.unknown { "Waiting for the world to end..." }
+  loop do
+    # Someone hit the exit button:
+    break if TIME_TO_DIE[0]
+    # We went through and did `ITERATIONS` update loops over the lights:
+    # ... the `- 1` is for the command queue thread!
+    unfinished = (threads.length - threads.count { |th| th.status == false }) - 1
+    break if USE_LIGHTS && unfinished == 0
+    sleep 0.25
+  end
+end
+
+def stop!(threads)
+  LOGGER.unknown { "Stopping threads..." }
+  %i(lights sweep graph input).each do |thread_group|
+    threads[thread_group].each(&:terminate)
+  end
+end
+
+def main
+  pre_init!
+
+  announce_iteration_config(ITERATIONS)
+
+  global_results  = defined?(Results) ? Results.new(logger: LOGGER) : nil
+  threads         = launch_all_threads!(CONFIG["simulation"], global_results)
+
+  wait_for_threads!(threads[:all])
+  init!(global_results)
+  wake!(threads[:all])
+  spin!(threads[:lights])
+  stop!(threads)
+
+  LOGGER.unknown { "Doing final shutdown..." }
+  global_results.done! if global_results
+  clear_board!
+
+  print_results(global_results) if global_results
+  dump_debug_data!
+  exit 127 if TIME_TO_DIE[1] == :restart
+end
+
+def profile!(&block)
+  unless PROFILE_RUN == "memory_profiler"
+    block.call
+    return
+  end
+
+  LOGGER.unknown { "Enabling memory_profiler, be careful!" }
+  require "memory_profiler"
+  report = MemoryProfiler.report do
+    block.call
+    LOGGER.unknown { "Preparing MemoryProfiler report." }
+  end
+  LOGGER.unknown { "Dumping MemoryProfiler report." }
+  # TODO: Dump this to a file...
+  report.pretty_print
+end
+
+###############################################################################
+# Launcher
+###############################################################################
+profile! do
+  bench_end! if defined?(bench_end!)
+  main
+end