ws_light 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dbf069c0977c0d9f8df28c61681c404780820a38
+  data.tar.gz: 5119cbe7ce8d5014ff8b9b63c299a68ef266dcb9
+SHA512:
+  metadata.gz: 9792d608a3f9859c70ff2c5319d6abb4480f21a4b39bbb7385c735fdbbe16e274184e1d45e347c2880ea38be1e6557ca4c9128d56a672b88f6fb2b652c9f9e5e
+  data.tar.gz: 2adef99d7dee1b1f081d510189535ab4b813697252e19bf9f1cd48e9a97971a9ef1e3428e8e9fa0da5d68e94a3d38f26a9b15b5f23e0aff3d542f52e7f6e9d0f

data/.gitignore

@@ -0,0 +1,5 @@
+/.idea
+*.log
+
+# Ignore built gems
+*.gem

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Gerrit Visscher
+
+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,13 @@
+# led_strip
+
+This gem is used (by me) to control my two led strip in my apartment. It is connected to two motion detectors and
+lights up my hall from the direction I enter. This gem is probably quite useless without a description of the
+hardware I am using. This will follow here once it works sufficiently.
+
+If you are interested, drop me a note.
+
+At the moment, you would need:
+- A raspberry pi or another computer with an SPI interface
+- One or two WS2801 led strips
+- One or two motion detectors, something like a HC-SR501
+- A power supply (obviously)

data/bin/ws_light

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+DEBUG = true
+
+if ARGV[0] && ARGV[0]=='-b'
+  case ARGV[1]
+  when 'set'
+    require 'ws_light/benchmark/set_benchmark'
+  when 'animation'
+    require 'ws_light/benchmark/animation_benchmark'
+  when 'ws2801'
+    require 'ws_light/benchmark/ws2801_benchmark'
+  else
+    puts 'Available benchmarks: set, animation, ws2801'
+  end
+  exit
+end
+
+require 'pi_piper'
+
+include PiPiper
+
+require 'bundler'
+require 'ws_light/strip'
+require 'ws_light/sd_logger'
+
+logger = WSLight::SDLogger.new
+logger.debug = DEBUG
+logger.filename = 'motion.log'
+logger.log 'Starting up'
+
+# Trap ^C 
+Signal.trap('INT') {
+  logger.log 'Shutting down'
+  logger.write_log
+  exit
+}
+ 
+# Trap `kill `
+Signal.trap('TERM') {
+  logger.log 'Shutting down'
+  logger.write_log
+  exit
+}
+
+strip = WSLight::Strip.new
+strip.debug = DEBUG
+
+pin_right = PiPiper::Pin.new(:pin => 22, :direction => :in)
+pin_left = PiPiper::Pin.new(:pin => 23, :direction => :in)
+
+after :pin => 23, :goes => :high do
+  logger.log('Motion detected: RIGHT')
+  strip.on(WSLight::Strip::DIRECTION_RIGHT)
+  while pin_right.on?
+  	strip.on(WSLight::Strip::DIRECTION_RIGHT)
+  	sleep 1
+  end
+end
+
+after :pin => 24, :goes => :high do
+  logger.log('Motion detected: LEFT')
+  strip.on(WSLight::Strip::DIRECTION_LEFT)
+  while pin_left.on?
+  	strip.on(WSLight::Strip::DIRECTION_LEFT)
+  	sleep 1
+  end
+end
+
+PiPiper.wait
+	

data/lib/ws_light/animation/base_animation.rb

@@ -0,0 +1,21 @@
+module WSLight
+  module Animation
+    # Base class for all animations, defines common methods
+    class BaseAnimation
+      attr_accessor :set_from, :set_to, :type
+
+      def initialize(set_from, set_to)
+        @set_from = set_from
+        @set_to = set_to
+      end
+
+      def frame_data(count)
+        frame(count).collect{|color| color.to_a}.flatten
+      end
+
+      def frames_per_second
+        25.0
+      end
+    end
+  end
+end

data/lib/ws_light/animation/fade_animation.rb

@@ -0,0 +1,31 @@
+require 'ws_light/animation/base_animation'
+
+module WSLight
+  module Animation
+    # Slides from one set to another from left to right (obviously depending on the hardware setup)
+    class FadeAnimation < BaseAnimation
+      FADE_DURATION = 50
+
+      def frames
+        FADE_DURATION + 1
+      end
+
+      def frame(count)
+        set = []
+
+        @set_from.next_frame
+        @set_to.next_frame
+
+        @set_from.full_length.times do |i|
+          set << @set_from.pixel(i).mix(@set_to.pixel(i), count.to_f/FADE_DURATION.to_f)
+        end
+
+        set
+      end
+
+      def frames_per_second
+        nil
+      end
+    end
+  end
+end

data/lib/ws_light/animation/slide_left_animation.rb

@@ -0,0 +1,38 @@
+require 'ws_light/animation/base_animation'
+
+module WSLight
+  module Animation
+    # Slides from one set to another from left to right (obviously depending on the hardware setup)
+    class SlideLeftAnimation < BaseAnimation
+      def frames
+        @set_from.length + 1 # one for each led plus one for all zero
+      end
+
+      def frame(count)
+        set = []
+        reverse_set = []
+
+        @set_from.next_frame
+        @set_to.next_frame
+
+        (set_from.length - count).times do |i|
+          set << set_from.pixel(i)
+          reverse_set << set_from.pixel((set_from.length * 2) - 1 - i) if set_from.type == :double
+        end
+
+        count.times do |i|
+          set << set_to.pixel(set_from.length - count + i)
+          reverse_set << set_to.pixel(set_from.length + count - 1 - i) if set_from.type == :double
+        end
+
+        set += reverse_set.reverse if set_from.type == :double
+
+        set
+      end
+
+      def frames_per_second
+        nil
+      end
+    end
+  end
+end

data/lib/ws_light/animation/slide_right_animation.rb

@@ -0,0 +1,39 @@
+require 'ws_light/animation/base_animation'
+
+module WSLight
+  module Animation
+    # Slides from one set to another from right to left (obviously depending on the hardware setup)
+    class SlideRightAnimation < BaseAnimation
+
+      def frames
+        @set_from.length + 1 # one for each led plus one for all zero
+      end
+
+      def frame(count)
+        set = []
+        reverse_set = []
+
+        @set_from.next_frame
+        @set_to.next_frame
+
+        count.times do |i|
+          set << set_to.pixel(i)
+          reverse_set << set_to.pixel((set_from.length * 2) - 1 - i)
+        end
+
+        (set_from.length - count).times do |i|
+          set << set_from.pixel(i + count)
+          reverse_set << set_from.pixel((set_from.length * 2) - count - 1 - i)
+        end
+
+        set += reverse_set.reverse if set_from.type == :double
+
+        set
+      end
+
+      def frames_per_second
+        nil
+      end
+    end
+  end
+end

data/lib/ws_light/benchmark/animation_benchmark.rb

@@ -0,0 +1,29 @@
+require 'ws_light/animation/fade_animation'
+require 'ws_light/animation/slide_left_animation'
+require 'ws_light/animation/slide_right_animation'
+require 'ws_light/set/color_set'
+
+require 'benchmark'
+include Benchmark
+
+
+color_set_from = WSLight::Set::ColorSet.new
+color_set_from.color = WSLight::Color.new(255, 127, 0)
+color_set_to = WSLight::Set::ColorSet.new
+color_set_to.color = WSLight::Color.new(0, 127, 255)
+
+@fade_animation = WSLight::Animation::FadeAnimation.new(color_set_from, color_set_to)
+@slide_left_animation = WSLight::Animation::SlideLeftAnimation.new(color_set_from, color_set_to)
+@slide_right_animation = WSLight::Animation::SlideRightAnimation.new(color_set_from, color_set_to)
+
+n = 10_000
+
+puts "Testing #{n} animation cycles with a simple color set..."
+
+Benchmark.bm(15) do |x|
+  x.report('FadeAnimation:') { n.times do @fade_animation.frame(n%50) end }
+  x.report('SlideLeftAnimation:') { n.times do @slide_left_animation.frame(n%50) end }
+  x.report('SlideRightAnimation:') { n.times do @slide_right_animation.frame(n%50) end }
+end
+
+puts "To run smoothly, the benchmarks should all be lower than #{n/50.0} seconds."

data/lib/ws_light/benchmark/set_benchmark.rb

@@ -0,0 +1,35 @@
+require 'ws_light/set/gradient_set'
+require 'ws_light/set/rainbow_set'
+require 'ws_light/set/semolina_set'
+require 'ws_light/set/random_set'
+require 'ws_light/set/strawberry_set'
+require 'ws_light/set/watermelon_set'
+
+
+require 'benchmark'
+include Benchmark
+
+@gradient_set = WSLight::Set::GradientSet.new
+@rainbow_set = WSLight::Set::RainbowSet.new
+@semolina_set = WSLight::Set::SemolinaSet.new
+@random_set = WSLight::Set::RandomSet.new
+@strawberry_set = WSLight::Set::StrawberrySet.new
+@watermelon_set = WSLight::Set::WatermelonSet.new
+
+@gradient_set.color_from = WSLight::Color.random_from_set
+@gradient_set.color_to = WSLight::Color.random_from_set
+
+n = 10_000
+
+puts "Testing #{n} cycles over all sets..."
+
+Benchmark.bm(15) do |x|
+  x.report('GradientSet:') { n.times do @gradient_set.frame end }
+  x.report('RainbowSet:') { n.times do @rainbow_set.frame end }
+  x.report('SemolinaSet:') { n.times do @semolina_set.frame end }
+  x.report('RandomSet:') { n.times do @random_set.frame end }
+  x.report('StrawberrySet:') { n.times do @strawberry_set.frame end }
+  x.report('WatermelonSet:') { n.times do @watermelon_set.frame end }
+end
+
+puts "To run smoothly, the benchmarks should all be lower than #{n/50.0} seconds."

data/lib/ws_light/benchmark/ws2801_benchmark.rb

@@ -0,0 +1,18 @@
+require 'ws2801'
+require 'benchmark'
+include Benchmark
+
+WS2801.length(320)
+
+light = [1] * 320 * 3
+dark = [0] * 320 * 3
+
+n = 1000
+
+puts "Testing #{n} writes to the led strip..."
+
+Benchmark.bm(15) do |x|
+  x.report('Write:') { n.times do |i| WS2801.strip(i % 2 == 0 ? light : dark); WS2801.write end }
+end
+
+puts "To run smoothly, the benchmarks should all be lower than #{n/50.0} seconds."

data/lib/ws_light/color.rb

@@ -0,0 +1,65 @@
+module WSLight
+  class Color
+    attr_accessor :r, :g, :b
+
+    COLORS = {
+      pink: { r: 255, g: 16, b:32 },
+      red: { r: 255, g: 0, b: 0},
+      blue: { r: 0, g: 0, b: 255},
+      green: { r: 0, g: 255, b: 0},
+      cyan: { r: 0, g: 127, b: 127},
+      orange: {r: 255, g:70, b: 0},
+      yellow: {r: 255, g:220, b: 0},
+      purple: {r: 80, g:0, b: 180}
+    }
+
+    def initialize(r=0, g=0, b=0)
+      @r = r > 255 ? 255 : r.to_i
+      @g = g > 255 ? 255 : g.to_i
+      @b = b > 255 ? 255 : b.to_i
+      @r = @r < 0 ? 0 : @r
+      @g = @g < 0 ? 0 : @g
+      @b = @b < 0 ? 0 : @b
+    end
+
+    def to_a
+      [@b, @g, @r]
+    end
+
+    def mix(other, ratio)
+      Color.new(
+          (@r * (1-ratio) + other.r * ratio).to_i,
+          (@g * (1-ratio) + other.g * ratio).to_i,
+          (@b * (1-ratio) + other.b * ratio).to_i
+      )
+    end
+
+    def mix!(other, ratio)
+      @r = (@r * (1-ratio) + other.r * ratio).to_i
+      @g = (@g * (1-ratio) + other.g * ratio).to_i
+      @b = (@b * (1-ratio) + other.b * ratio).to_i
+      self
+    end
+
+    def self.random
+      Color.new(rand(192), rand(192), rand(192))
+    end
+
+    def self.by_name(name)
+      if Color::COLORS[name]
+        selected_color = Color::COLORS[name]
+        Color.new(selected_color[:r], selected_color[:g], selected_color[:b])
+      elsif name == :black
+        Color.new(0, 0, 0)
+      else
+        fail "Cannot find color #{name}"
+      end
+    end
+
+    def self.random_from_set
+      color_values = Color::COLORS.values
+      selected_color = color_values[rand(color_values.length)]
+      Color.new(selected_color[:r], selected_color[:g], selected_color[:b])
+    end
+  end
+end

data/lib/ws_light/sd_logger.rb

@@ -0,0 +1,40 @@
+module WSLight
+  # Provides a logger which writes only in long intervals, thus reducing write access to the cd card
+  # (out data is not that crucial)
+  class SDLogger
+    attr_accessor :entries, :interval, :entries, :debug, :filename
+
+    def initialize
+      @filename = 'log.txt'
+      @interval = 1800 # log interval in seconds
+      @entries = []
+      @last_write = Time.now
+      @debug = false
+    end
+
+    def log(text)
+      puts Time.now.to_s + ' -> ' + text if @debug
+      entries << {
+        text: text,
+        time: Time.now
+      }
+      write_log if timeout?
+    end
+
+    def write_log
+      return if @entries.empty?
+      file = File.open(@filename, File.exists?(@filename) ? 'a' : 'w')
+      @entries.each do |entry|
+        file.puts(entry[:time].to_s + ', ' + entry[:text])
+      end
+      file.close
+      @entries = []
+      @last_write = Time.now
+    end
+
+    def timeout?
+      (Time.now - @last_write) > @interval
+    end
+
+  end
+end

data/lib/ws_light/set/color_set.rb

@@ -0,0 +1,47 @@
+require 'ws_light/color'
+
+module WSLight
+  module Set
+    # Base set with one color
+    class ColorSet
+      DEFAULT_LENGTH = 160
+      DEFAULT_TYPE = :double
+
+      attr_accessor :type, :length, :color, :full_length
+
+      def initialize(length = DEFAULT_LENGTH, type = DEFAULT_TYPE)
+        @length = length
+        @type = type
+        @full_length = (@type == :double ? @length * 2 : @length)
+        @color = Color.random
+        @frame_count = 0
+        init
+      end
+
+      def frame_data
+        frame.collect{|color| color.to_a}.flatten
+      end
+
+      def frame
+        length = type == :double ? @length * 2 : @length
+        set = []
+        length.times do
+          set << @color
+        end
+        set
+      end
+
+      def next_frame
+        # reimplement if necessary, please :)
+      end
+
+      def pixel(_number, _frame = 0)
+        @color
+      end
+
+      def init
+        # do some initializing stuff here
+      end
+    end
+  end
+end

data/lib/ws_light/set/gradient_set.rb

@@ -0,0 +1,35 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates a gradient from one color to another
+    class GradientSet < ColorSet
+      attr_accessor :color_from, :color_to
+
+      def init
+        @color_from = Color.new(0,0,0)
+        @color_to = Color.new(255,255,255)
+      end
+
+      def frame
+        @set ||= create_frame
+      end
+
+      def create_frame
+        set = []
+        @length.times do |i|
+          set << pixel(i)
+        end
+
+        set += set.reverse if type == :double # this should be faster than generating the pixel one after another
+
+        set
+      end
+
+      def pixel(number)
+        number = @full_length - 1 - number if number >= @length
+        @color_from.mix(@color_to, number.to_f/(@length-1))
+      end
+    end
+  end
+end

data/lib/ws_light/set/rainbow_set.rb

@@ -0,0 +1,40 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates a moving rainbow (actually a color circle)
+    class RainbowSet < ColorSet
+      def init
+        @frequency = Math::PI / @length
+      end
+
+      def next_frame
+        @frame_count += 1
+      end
+
+      def frame
+        next_frame
+        set = []
+
+        @length.times do |i|
+          set << pixel(i)
+        end
+
+        set += set.reverse if type == :double
+
+        set
+      end
+
+      def pixel(number)
+        number = @full_length - 1 - number if number >= @length
+        x = @frequency*(number+@frame_count)
+        Color.new(
+            (Math.sin(x)**2 * 127),
+            (Math.sin(x + 2.0*Math::PI/3.0)**2 * 127),
+            (Math.sin(x + 4.0*Math::PI/3.0)**2 * 127)
+        )
+      end
+
+    end
+  end
+end

data/lib/ws_light/set/random_set.rb

@@ -0,0 +1,24 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates a set with all random colors
+    class RandomSet < ColorSet
+      def frame
+        @set ||= generate_set
+      end
+
+      def pixel(number, _frame = 0)
+        frame[number]
+      end
+
+      def generate_set
+        set = []
+        @full_length.times do
+          set << Color.random
+        end
+        set
+      end
+    end
+  end
+end

data/lib/ws_light/set/semolina_set.rb

@@ -0,0 +1,56 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates semolina with raspberries
+    class SemolinaSet < ColorSet
+      COLOR_SEMOLINA = Color.new(255, 127, 15)
+      COLOR_RASPBERRY = Color.new(255, 7, 15)
+      RASPBERRY_SIZE = 10
+      RASPBERRY_COUNT = 8
+
+      def init
+        @raspberries = []
+
+        while @raspberries.size < RASPBERRY_COUNT do
+          position = rand(@full_length)
+          @raspberries << position unless (at_end?(position) || between_strips?(position) || is_raspberry?(position))
+        end
+      end
+
+      def between_strips?(position)
+
+        @type == :double && ((@full_length/2 - 1 - RASPBERRY_SIZE)..(@full_length/2)).include?(position)
+      end
+
+      def at_end?(position)
+        position >= (@full_length - 1 - RASPBERRY_SIZE)
+      end
+
+      def frame
+        @set ||= create_frame
+      end
+
+      def create_frame
+        set = []
+
+        @full_length.times do |i|
+          set << (is_raspberry?(i) ? COLOR_RASPBERRY : COLOR_SEMOLINA)
+        end
+
+        set
+      end
+
+      def is_raspberry?(pixel)
+        @raspberries.each do |raspberry|
+          return true if pixel > raspberry && pixel < (raspberry + RASPBERRY_SIZE)
+        end
+        false
+      end
+
+      def pixel(number)
+        frame[number]
+      end
+    end
+  end
+end

data/lib/ws_light/set/star_set.rb

@@ -0,0 +1,60 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates a set with all random colors
+    class StarSet < ColorSet
+      FRAMES_PER_STAR = 75
+      VISIBLE_STARS = 7
+      BLACK = Color.new(0,0,0)
+
+      def init
+        @stars = (0..(@full_length-4)).to_a.shuffle
+        @max = @stars.size
+        @stars += @stars[@stars.size - VISIBLE_STARS, VISIBLE_STARS]
+        generate_frame
+      end
+
+      def next_frame
+        @frame_count += 1
+        @frame_count = @frame_count % (@max * FRAMES_PER_STAR)
+        generate_frame
+      end
+
+      def frame
+        next_frame
+        @set
+      end
+
+      def generate_frame
+        @set = []
+        @full_length.times{ @set << BLACK }
+        start = (@frame_count * VISIBLE_STARS / FRAMES_PER_STAR) % @max
+        VISIBLE_STARS.times do |i|
+            draw_star(@stars[start + i], @frame_count - ((start - VISIBLE_STARS + 1 + i) * (FRAMES_PER_STAR.to_f / VISIBLE_STARS.to_f)).to_i)
+        end
+      end
+
+      def draw_star(position, star_frame)
+        #(-3..3).each do |i|
+        #  white = brightness(i.abs, (star_frame - (FRAMES_PER_STAR/2)).abs)
+        #  @set[position + i] = Color.new(white, white, white)
+        #end
+        #return if star_frame < 0
+        white = brightness(0, (star_frame.to_f - (FRAMES_PER_STAR.to_f/2.0)).abs)
+        #puts "#{position}, #{star_frame}, #{(star_frame.to_f - (FRAMES_PER_STAR.to_f/2.0)).abs}, #{white}"
+        @set[position] = Color.new(white, white, white)
+      end
+
+      def pixel(number)
+        @set[number]
+      end
+
+      def brightness(led_distance, frame_distance)
+        #return 0 if led_distance > 3
+        #(2 ** ((3 - led_distance) * 3 - 1) - 1) * (1 - (frame_distance/(FRAMES_PER_STAR/2)))
+        (255 * (1.0 - (frame_distance.to_f/(FRAMES_PER_STAR.to_f/2.0)))).to_i
+      end
+    end
+  end
+end

data/lib/ws_light/set/strawberry_set.rb

@@ -0,0 +1,48 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates a strawberry set, some green, lots of pinkish red with a few greenish dots
+    class StrawberrySet < ColorSet
+      LENGTH_RED = 0.9
+      COLOR_NUT = Color.new(220, 255, 15)
+
+      def frame
+        @set ||= create_frame
+      end
+
+      def create_frame
+        set = []
+
+        length_red = (LENGTH_RED * @length).to_i
+
+
+        color_strawberry = Color.new(255, 7, 15)
+        color_leaves = Color.new(15, 191, 15)
+
+        @length.times do |i|
+          set << (i < length_red ? color_strawberry : color_leaves)
+        end
+
+        set = sprinkle_nuts(set)
+
+        type == :double ? set + set.reverse : set
+      end
+
+      def sprinkle_nuts(set)
+        length_red = (LENGTH_RED * @length).to_i
+        distance = 0
+        while distance < length_red - 21
+          distance += 15 + rand(5)
+          set[distance] = COLOR_NUT
+        end
+
+        set
+      end
+
+      def pixel(number)
+        frame[number]
+      end
+    end
+  end
+end

data/lib/ws_light/set/watermelon_set.rb

@@ -0,0 +1,42 @@
+require 'ws_light/set/color_set'
+
+module WSLight
+  module Set
+    # Creates a watermelon set, some green, some white, lots of red with a few red dots
+    class WatermelonSet < ColorSet
+      def create_frame
+        set = []
+
+        length_red = (0.72 * @length).to_i
+        length_red_to_white = (0.1 * @length).to_i
+        length_white = (0.1 * @length).to_i
+
+        white = Color.new(255, 255, 255)
+        red = Color.new(255, 0, 0)
+
+        @length.times do |i|
+          if i < length_red
+            set << Color.new((rand(25) < 1 ? 0 : 255), 0, 0)
+          elsif i < length_red + length_red_to_white
+            ratio = (i - length_red) / (length_red + length_red_to_white)
+            set << red.mix(white, ratio)
+          elsif i < length_red + length_red_to_white + length_white
+            set << white
+          else
+            set << Color.new(0, 127, 0)
+          end
+        end
+
+        type == :double ? set + set.reverse : set
+      end
+
+      def frame
+        @set ||= create_frame
+      end
+
+      def pixel(number)
+        frame[number]
+      end
+    end
+  end
+end

data/lib/ws_light/strip.rb

@@ -0,0 +1,218 @@
+require 'ws2801'
+require 'ws_light/color'
+require 'pp'
+require 'date'
+require 'json'
+require 'open-uri'
+
+require 'ws_light/animation/slide_left_animation'
+require 'ws_light/animation/slide_right_animation'
+require 'ws_light/animation/fade_animation'
+
+require 'ws_light/set/color_set'
+require 'ws_light/set/gradient_set'
+require 'ws_light/set/random_set'
+require 'ws_light/set/rainbow_set'
+require 'ws_light/set/strawberry_set'
+require 'ws_light/set/watermelon_set'
+require 'ws_light/set/semolina_set'
+require 'ws_light/set/star_set'
+
+
+
+# Ideas
+# - Fire?
+# Config file
+
+module WSLight
+  # Controls the led strip
+  class Strip
+    attr_accessor :direction, :last_event, :state, :current_set, :debug
+
+    LENGTH = 160
+    TYPE = :double
+
+    DIRECTION_NONE = 0
+    DIRECTION_LEFT = 1
+    DIRECTION_RIGHT = 2
+    TIMEOUT = 12
+
+    STATE_OFF = :state_off
+    STATE_ON = :state_on
+    STATE_STARTING_UP = :state_starting_up
+    STATE_SHUTTING_DOWN = :state_shutting_down
+
+    WEATHER_URL = 'http://api.openweathermap.org/data/2.5/weather?q=Hannover,de'
+
+    FRAMES_PER_SECOND = 25
+
+    def initialize
+      WS2801.length(Strip::TYPE == :double ? Strip::LENGTH * 2 : Strip::LENGTH)
+      WS2801.autowrite(true)
+      update_daylight
+      self_test
+      @listen_thread = Thread.new { while true do check_timer; sleep 0.5; end }
+      @last_event = Time.now - 3600 # set last event to a longer time ago
+      @state = STATE_OFF
+      @debug = false
+      @current_set = Set::ColorSet.new
+      @current_set.color = Color.new(0,0,0)
+    end
+
+    def on(direction)
+      @last_event = Time.now
+      puts "triggered event 'on': #{last_event.to_f} from state #{@state}" if @debug
+      @state = STATE_STARTING_UP if @state == STATE_SHUTTING_DOWN
+      return if @state != STATE_OFF
+
+      puts 'Loading a new set...' if @debug
+
+      @direction = direction
+      @state = STATE_STARTING_UP
+
+      case rand(100)
+      when 0..3
+        set = Set::RainbowSet.new
+      when 4..6
+        set = Set::RandomSet.new
+      when 7..9
+        set = Set::StrawberrySet.new
+      when 10..12
+        set = Set::WatermelonSet.new
+      when 13..15
+        set = Set::SemolinaSet.new
+      else
+        set = Set::GradientSet.new
+        set.color_from = Color.random_from_set
+        set.color_to = Color.random_from_set
+      end
+
+      set = Set::StarSet.new if night?
+
+      puts "Set #{set.class}" if @debug
+
+      animation = animation_for(direction).new(@current_set, set)
+
+      animate(animation)
+      @current_set = set
+
+      @state = STATE_ON
+
+      # Move show() into background, so we can accept new events on the main thread
+      Thread.new { show(@current_set, animation.frames) }
+    end
+
+    def off(direction = nil)
+      puts "triggered event 'off': #{Time.now.to_f} during state #{@state}" if @debug
+      return if @state != STATE_ON
+
+      @state = STATE_SHUTTING_DOWN
+      sleep 0.2
+      @direction = direction if direction
+
+      set = Set::ColorSet.new
+      set.color = Color.by_name :black
+
+      animation = animation_for(@direction).new(@current_set, set)
+
+      if animate(animation)
+        @state = STATE_OFF
+        @current_set = set
+      else
+        @state = STATE_ON
+        Thread.new { show(@current_set, animation.frames) }
+      end
+
+      puts "finished shutting off: #{Time.now.to_f}" if @debug
+    end
+
+    def animation_for(direction)
+      return Animation::FadeAnimation if night?
+
+      if direction == DIRECTION_LEFT
+        Animation::SlideLeftAnimation
+      else
+        Animation::SlideRightAnimation
+      end
+    end
+
+    def animate(animation)
+      current_frame = 0
+      beginning_state = @state
+
+      animation.frames.times do |i|
+        WS2801.strip(animation.frame_data(current_frame = i))
+        WS2801.write
+        sleep (1.0/animation.frames_per_second) if animation.frames_per_second
+        break if @state != beginning_state # Reverse shutting off when a new event is triggered
+      end
+
+      # This is run when the animation is reversed
+      if (current_frame + 1) < animation.frames
+        current_frame.times do |i|
+          WS2801.strip(animation.frame_data(current_frame - i - 1))
+          WS2801.write
+          sleep (1.0/animation.frames_per_second) if animation.frames_per_second
+        end
+        false
+      else
+        true
+      end
+    end
+
+    def show(set, start_frame = 0)
+      current_state = @state
+      i = start_frame
+      while @state == current_state
+        WS2801.strip(set.frame_data)
+        WS2801.write
+        sleep 1.0/FRAMES_PER_SECOND.to_f
+        i += 1
+      end
+    end
+
+    def night?
+      time = Time.now
+      time.to_i < (@daylight[:start] - 3600) || time.to_i > (@daylight[:end] + 3600)
+    end
+
+    # Gets the sunset/sunrise data
+    # this might get out of sync when the clock is not set correctly
+    # anyway, one day off is not a problem :)
+    def update_daylight
+      data = JSON.parse(open(WEATHER_URL).read)
+      @daylight = {
+        start: data['sys']['sunrise'].to_i,
+        end: data['sys']['sunset'].to_i,
+        day: Time.now.day
+      }
+      pp @daylight
+    end
+
+    def shutdown
+      WS2801.set(r: 0, g: 0, b: 0)
+    end
+
+    def self_test
+      WS2801.set(r: 0, g: 0, b: 255)
+      sleep 1
+      WS2801.set(r: 0, g: 255, b: 0)
+      sleep 1
+      WS2801.set(r: 255, g: 0, b: 0)
+      sleep 1
+      WS2801.set(r: 0, g: 0, b: 0)
+    end
+
+    def check_timer
+      WS2801.set(r: 0, g: 0, b: 0) if @state == STATE_OFF
+      # Test after 2 a.m. to make sure we can the correct date even if our time is slightly off
+      time = Time.now
+      update_daylight if @daylight[:day] != time.day && time.hour > 1
+      off if timeout?
+    end
+
+    def timeout?
+      @last_event < (Time.now - TIMEOUT)
+    end
+  end
+end

data/lib/ws_light/version.rb

@@ -0,0 +1,4 @@
+# Provides a global version number
+module WSLight
+  VERSION = '0.2.0'
+end

data/ws_light.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ws_light/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ws_light'
+  spec.version       = WSLight::VERSION
+  spec.authors       = ['Gerrit Visscher']
+  spec.email         = ['g.visscher@core4.de']
+  spec.summary       = 'A lighting gem for WS2801 led strips.'
+  spec.description   = 'Controls one or two WS2801 led strips with a Raspberry Pi or another computer with an SPI interface.'
+  spec.homepage      = 'https://github.com/kayssun/ws_light'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+
+  spec.add_runtime_dependency 'pi_piper', '~>1'
+  spec.add_runtime_dependency 'ws2801', '~>1'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: ws_light
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Gerrit Visscher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: pi_piper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: ws2801
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Controls one or two WS2801 led strips with a Raspberry Pi or another
+  computer with an SPI interface.
+email:
+- g.visscher@core4.de
+executables:
+- ws_light
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- bin/ws_light
+- lib/ws_light/animation/base_animation.rb
+- lib/ws_light/animation/fade_animation.rb
+- lib/ws_light/animation/slide_left_animation.rb
+- lib/ws_light/animation/slide_right_animation.rb
+- lib/ws_light/benchmark/animation_benchmark.rb
+- lib/ws_light/benchmark/set_benchmark.rb
+- lib/ws_light/benchmark/ws2801_benchmark.rb
+- lib/ws_light/color.rb
+- lib/ws_light/sd_logger.rb
+- lib/ws_light/set/color_set.rb
+- lib/ws_light/set/gradient_set.rb
+- lib/ws_light/set/rainbow_set.rb
+- lib/ws_light/set/random_set.rb
+- lib/ws_light/set/semolina_set.rb
+- lib/ws_light/set/star_set.rb
+- lib/ws_light/set/strawberry_set.rb
+- lib/ws_light/set/watermelon_set.rb
+- lib/ws_light/strip.rb
+- lib/ws_light/version.rb
+- ws_light.gemspec
+homepage: https://github.com/kayssun/ws_light
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A lighting gem for WS2801 led strips.
+test_files: []