cheeky-dreams 0.0.4 → 0.0.5

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/cheeky-dreams.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "cheeky-dreams"
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["simon"]
-  s.date = "2011-11-02"
+  s.date = "2011-11-17"
   s.description = "For controlling dream cheeky usb light"
   s.email = "simojenki@gmail.com"
   s.extra_rdoc_files = [
@@ -28,6 +28,8 @@ Gem::Specification.new do |s|
     "cheeky-dreams.gemspec",
     "lib/cheeky-dreams.rb",
     "spec/cheeky-dreams_spec.rb",
+    "spec/off.rb",
+    "spec/small-test.rb",
     "spec/spec_helper.rb",
     "spec/support/collecting_auditor.rb",
     "spec/support/stub_driver.rb",

data/lib/cheeky-dreams.rb

@@ -1,11 +1,18 @@
 require 'thread'
 
 module CheekyDreams
-
-  def rgb r, g, b
-    [r, g, b].each { |c| raise "Invalid rgb value #{r}, #{g}, #{b}" if c < 0 || c > 255}
-    [r, g, b]
-  end
+  
+  COLOURS = { 
+    :off => [0, 0, 0],
+    :red => [255, 0, 0],
+    :green => [0, 255, 0],
+    :blue => [0, 0, 255],
+    :yellow => [255,255,0],
+    :aqua => [0,255,255],
+    :purple => [255,0,255],
+    :grey => [192,192,192],
+    :white => [255,255,255]
+  }
   
   def rgb_between a, b, ratio
     [
@@ -15,58 +22,84 @@ module CheekyDreams
       ]
   end
   
+  def sleep_until time
+    zzz_time = time - Time.now
+    sleep(zzz_time) if zzz_time > 0
+  end
+  
   def position_between a, b, ratio
     return b if ratio >= 1.0
     (((b - a) * ratio) + a).floor
   end
 
-  COLOURS = { 
-    :off => [0, 0, 0],
-    :red => [255, 0, 0],
-    :green => [0, 255, 0],
-    :blue => [0, 0, 255],
-    :yellow => [255,255,0],
-    :aqua => [0,255,255],
-    :purple => [255,0,255],
-    :grey => [192,192,192],
-    :white => [255,255,255]
-  }
-  
-  def rgb_for colour
-    case colour
-    when Symbol
-      raise "Unknown colour '#{colour}'" unless COLOURS.has_key?(colour)
-      COLOURS[colour]
-    when Array
-      raise "Invalid rgb #{colour}" unless colour.length == 3 && colour.all? { |c| c.is_a? Fixnum }
-      rgb(colour[0], colour[1], colour[2])
+  def rgb *rgb_args
+    raise 'Cannot give rgb for nil!' unless rgb_args
+    args = rgb_args.flatten
+    if args.length == 1 && args[0].is_a?(Symbol)
+      raise "Unknown colour '#{args[0]}'" unless COLOURS.has_key?(args[0])
+      COLOURS[args[0]]
+    elsif (args.length == 3 && args.all? { |c| c.is_a? Numeric })
+      r, g, b = args[0].floor, args[1].floor, args[2].floor
+      [r, g, b].each { |c| raise "Invalid rgb value #{r}, #{g}, #{b}" if c < 0 || c > 255}
+      [r, g, b]
     else 
-      raise "Unsupported colour type #{colour}"
+      raise "Invalid rgb #{args}"
     end
   end
-  
-  def stderr_auditor
-    Class.new do
-      def unhandled_error e
-        STDERR.puts e.message
-        STDERR.puts e.backtrace.join("\n")
+
+  class FilteringAuditor
+    def initialize auditor, including
+      @auditor, @including = auditor, Set.new(including)
+    end
+    
+    def audit type, message
+      @auditor.audit(type, message) if @including.include?(type)
+    end
+  end
+
+  class StdIOAuditor
+    def initialize out = STDOUT, err = STDERR
+      @out, @err = out, err
+    end
+    
+    def audit type, message
+      case type
+      when :error
+        @err.puts "#{type} - #{message}"
+      else
+        @out.puts "#{type} - #{message}"
       end
-    end.new
+    end
   end
   
-  def dev_null_auditor
-    Class.new do
-      def unhandled_error e
-      end
-    end.new
+  def filtering including, auditor
+    FilteringAuditor.new auditor, including
+  end
+  
+  def audit_to *auditors
+    CompositeAuditor.new *auditors
+  end
+  
+  class CompositeAuditor
+    def initialize *auditors
+      @auditors = auditors
+    end
+    
+    def audit type, message
+      @auditors.each { |auditor| auditor.audit type, message }
+    end
+  end
+
+  def stdio_audit out = STDOUT, err = STDERR
+    StdIOAuditor.new(out, err)
+  end
+  
+  def dev_null
+    Dev::Null.new
   end
   
   def stdout_driver
-    Class.new do
-      def go rgb
-        puts rgb
-      end
-    end.new
+  	Dev::IO.new
   end
   
   def ansi_driver
@@ -80,10 +113,58 @@ module CheekyDreams
   end
   
   def find_dream_cheeky_usb_device
-    Device::DreamCheeky.new(File.dirname(Dir.glob('/sys/devices/**/red').first))
+    Dev::DreamCheeky.new(File.dirname(Dir.glob('/sys/devices/**/red').first))
+  end
+
+  def off
+    solid :off
+  end
+   
+  def solid colour
+    Effects::Solid.new(colour)
+  end
+
+  def cycle colours, freq = 1
+    Effects::Cycle.new(colours, freq)
+  end
+
+  def fade from, to, steps = 10, freq = 1
+    Effects::Fade.new from, to, steps, freq
+  end
+
+  def fade_to to, steps = 10, freq = 1
+    Effects::FadeTo.new to, steps, freq
+  end
+
+  def func freq = 1, &block
+    Effects::Func.new freq, &block
+  end
+
+  def throb freq, from, to
+    Effects::Throb.new freq, from, to
   end
   
-  module Device
+  def crazy freq = 1, new_effect_freq = 2
+  	Effects::Crazy.new(freq, new_effect_freq)
+  end
+   
+  module Dev
+    class Null
+      def audit type, message
+      end
+    end
+    
+    class IO
+    	def initialize io = $stdout
+    		@io, @last = io, nil
+    	end
+    	
+    	def go rgb
+    		@io.puts "[#{rgb.join(',')}]" unless rgb == @last
+    		@last = rgb
+    	end
+    end
+    
     class DreamCheeky
       attr_reader :path
       def initialize path, max_threshold = 50
@@ -105,7 +186,7 @@ module CheekyDreams
     end
   end
   
-  module Effect
+  module Effects
     class Effect
       include CheekyDreams    
       include Math
@@ -138,11 +219,12 @@ module CheekyDreams
         @r_centre, @r_amp = centre_and_amp from[0], to[0]
         @g_centre, @g_amp = centre_and_amp from[1], to[1]
         @b_centre, @b_amp = centre_and_amp from[2], to[2]
-        @count = 1
+        @sin_freq = 3.14 / freq.to_f
+        @count = (1.57 / @sin_freq).floor
       end
       
       def next current_colour
-        x = sin(freq * @count)
+        x = sin(@sin_freq * @count)
         r = x * r_amp + r_centre
         g = x * g_amp + g_centre
         b = x * b_amp + b_centre
@@ -151,7 +233,7 @@ module CheekyDreams
         # [v, 0, 0]
         
         @count += 1
-        [r, g, b]
+        [r.floor, g.floor, b.floor]
       end
       
       private 
@@ -166,6 +248,21 @@ module CheekyDreams
       end
     end
 
+    class Crazy < Effect 
+			def initialize freq, new_effect_freq
+				super freq
+				@new_effect_freq = new_effect_freq
+        @count, @effect = 0, nil
+			end
+
+			def next current_colour
+				if @count % @new_effect_freq == 0
+					@effect = FadeTo.new([rand(255), rand(255), rand(255)], @new_effect_freq, freq)
+			  end
+				@count += 1
+				@effect.next current_colour
+			end
+    end
     
     class Func < Effect
       def initialize freq, &block
@@ -174,14 +271,14 @@ module CheekyDreams
       end
       
       def next current_colour = nil
-        rgb_for(@block.yield(current_colour))
+        rgb(@block.yield(current_colour))
       end
     end
     
     class Solid < Effect
       def initialize colour
-        super 1
-        @rgb = rgb_for(colour)
+        super 0.1
+        @rgb = rgb(colour)
       end
       
       def next current_colour = nil
@@ -196,14 +293,14 @@ module CheekyDreams
       end
       
       def next current_colour = nil
-        rgb_for(@cycle.next)
+        rgb(@cycle.next)
       end
     end
     
     class Fade < Effect
       def initialize from, to, steps, freq
         super freq
-        @rgb_from, @rgb_to = rgb_for(from), rgb_for(to)
+        @rgb_from, @rgb_to = rgb(from), rgb(to)
         @fade = [@rgb_from]
         (1..(steps-1)).each { |i| @fade << rgb_between(@rgb_from, @rgb_to, i / steps.to_f) }
         @fade << @rgb_to
@@ -226,10 +323,7 @@ module CheekyDreams
       end
       
       def next current_colour
-        unless @fade
-          @fade = Fade.new(current_colour, @to, @steps, freq)
-          @fade.next current_colour
-        end
+        @fade = Fade.new(current_colour, @to, @steps, freq) unless @fade        
         @fade.next current_colour
       end
     end
@@ -238,85 +332,59 @@ end
 
 class Light
   
-  include CheekyDreams
-  
   attr_accessor :freq, :auditor
   
+  include CheekyDreams
+  
   def initialize driver
-    @driver, @freq, @auditor = driver, 100, dev_null_auditor
-    @lock = Mutex.new
-    @effect = nil
+    @driver, @freq, @auditor, @effect = driver, 50, dev_null, solid(:off)
+    @lock, @wake_up = Mutex.new, ConditionVariable.new
     @on = false
   end
   
-  def cycle colours, freq = 1
-    go(Effect::Cycle.new(colours, freq))
-  end
-  
-  def solid colour
-    go(Effect::Solid.new(colour))
-  end
-  
-  def fade from, to, steps = 10, freq = 1
-    go Effect::Fade.new from, to, steps, freq
-  end
-
-  def fade_to to, steps = 10, freq = 1
-    go Effect::FadeTo.new to, steps, freq
-  end
-  
-  def func freq = 1, &block
-    go Effect::Func.new freq, &block
-  end
-  
-  def throb freq, amplitude, centre
-    go Effect::Throb.new freq, amplitude, centre
-  end
-  
   def go effect
     @lock.synchronize {
       case effect
         when Symbol
-          @effect = Effect::Solid.new(effect)
+          @effect = solid(effect)
         when Array
-          @effect = Effect::Solid.new(effect)
-        when Effect::Effect
+          @effect = solid(effect)
+        when CheekyDreams::Effects::Effect
           @effect = effect
         else
           raise "Im sorry dave, I'm afraid I can't do that. #{effect}"
       end
     }
+    wakeup
     turn_on unless @on    
   end
   
+  def off
+    @on = false
+  end
+  
   private
   def turn_on
-    @on = true
-    Thread.new do
-      current_effect = nil
-      last_colour = nil
-      next_colour_time = nil
+    @on, current_effect = true, nil
+    @run_thread = Thread.new do
+      last_colour = COLOURS[:off]
       while @on
+        start = Time.now
+        @lock.synchronize { current_effect = @effect }
         begin
-          @lock.synchronize {
-            if @effect && current_effect != @effect
-              current_effect = @effect
-              next_colour_time = Time.at(0)
-            end
-          }
-          if current_effect
-            if Time.now > next_colour_time
-              new_colour = current_effect.next(last_colour)
-              @driver.go new_colour
-              last_colour = new_colour
-              next_colour_time = Time.now + (1 / current_effect.freq.to_f)
-            end
-          end
+          new_colour = current_effect.next last_colour
+          @driver.go new_colour
+          @auditor.audit :colour_change, new_colour.to_s
+          last_colour = new_colour
         rescue => e
-          auditor.unhandled_error e
+          auditor.audit :error, e.message
         end
-        sleep (1 / freq.to_f)
-      end
+        sleep_until (start + (1 / current_effect.freq.to_f))
+      end      
     end
   end
+  
+  def wakeup
+    @run_thread.run if @run_thread
+  end
 end