hue-lib 0.6.0 → 0.7.0

data/README.md

@@ -64,18 +64,19 @@ If you know the ID number of a particular lamp, you can access it directly.
 >> b.on?
 => true
 
-# settings
->> b.settings
-=> {"ct"=>343, "on"=>true, "bri"=>240}
-
+# brightness
 >> b.brightness = 128
 => 128
 
->> b.update hue: 45000, sat: 180
-=> true
+# color
+>> b.color = Hue::Colors::ColorTemperature.new(6500)
+=> Temperature=6500°K (153 mired)
+
+>> b.color = Hue::Colors::HueSaturation.new(10_000, 255)
+=> Hue=10000, Saturation=255
 
->> b.settings
-=> {"hue"=>45000, "sat"=>180, "on"=>true, "bri"=>128}
+>> b.color = Hue::Colors::XY.new(0.5, 0.5)
+=> XY=[0.5, 0.5]
 
 # blinking
 >> b.blinking?

data/hue-lib.gemspec

@@ -3,12 +3,13 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "hue-lib"
-  s.version     = '0.6.0'
+  s.version     = '0.7.0'
   s.authors     = ["Birkir A. Barkarson", "Aaron Hurley"]
   s.email       = ["birkirb@stoicviking.net"]
   s.homepage    = "https://github.com/birkirb/hue-lib"
-  s.summary     = %q{Ruby library for controlling Phillips Hue light bridge.}
-  s.description = s.summary
+  s.summary     = %q{Ruby library for controlling the Philips Hue system's lights and bridge.}
+  s.description = %q{Library allowing registration and invocation of a registered Philips Hue app.
+    Convinient objects allow executing commands on the bridge or individual bulbs.}
 
   s.rubyforge_project = "hue-lib"
 

data/lib/hue/animations/candle.rb

@@ -0,0 +1,54 @@
+module Hue
+  module Animations
+    module Candle
+
+      public
+
+      def candle(repeat = 15)
+        # 0-65536 for hue, 182 per deg. Ideal 30-60 deg (5460-10920)
+        stash!
+        on if off?
+
+        repeat.times do
+          hue = ((rand * 3460) + 5460).to_i
+          sat = rand(64) + 170
+          bri = rand(32) + 16
+
+          delay = (rand * 0.35) + (@delay ||= 0)
+          update(hue: hue, sat: sat, bri: bri, transitiontime: (delay * 10).to_i)
+          sleep delay
+        end
+        restore!
+      end
+
+      private
+
+      def options_with_colorstate
+        options.merge case state['colormode']
+                      when 'ct'
+                        {'ct' => state['ct']}
+                      when 'xy'
+                        {'xy' => state['xy']}
+                      when 'hs'
+                        {'hue' => state['hue'], 'sat' => state['sat']}
+                      end.merge('on' => state['on'], 'bri' => state['bri'])
+      end
+
+      def restore!
+        if stash
+          update(@stash)
+          unstash!
+        end
+      end
+
+      def stash!
+        @stash ||= options_with_colorstate
+      end
+
+      def unstash!
+        @stash = nil
+      end
+
+    end
+  end
+end

data/lib/hue/animations/sunrise.rb

@@ -0,0 +1,106 @@
+module Hue
+  module Animations
+    module Sunrise
+
+      SUN_STEPS = [ 1.5, 2, 3, 1, 4, 2.5 ]
+      SUN_TIMES = [ 3,   3, 3, 1, 2, 1]
+
+      public
+
+      # Experimental Sunrise/Sunset  action
+      # this will transition from off and warm light to on and daytime light
+      # in a curve that mimics the actual sunrise.
+
+      def perform_sunrise(total_time_in_minutes = 18)
+        # total_time / 18 steps == time_per_step
+        # the multiplier should be 600 * time per step
+        minutes_per_step = total_time_in_minutes / 18.0
+        multiplier = (minutes_per_step * 60 * 10).to_i
+
+        perform_sun_transition total_time_in_minutes, sunrise_steps(multiplier)
+      end
+
+      def perform_sunrise(total_time_in_minutes = 18)
+        multiplier = sunrise_multiplier total_time_in_minutes
+        steps = sunrise_steps(multiplier)
+        if on?
+          puts "ON! #{steps[0][:bri]} :: #{brightness} :: #{brightness > steps[0][:bri]}"
+          while brightness >= steps[0][:bri]
+            steps.shift
+          end
+        end
+        steps.each_with_index do |step, i|
+          update step.merge(on: true)
+          sleep(step[:transitiontime] / 10.0)
+        end
+      end
+
+      def perform_sunset(total_time_in_minutes = 18)
+        multiplier = sunrise_multiplier total_time_in_minutes
+        steps = sunset_steps(multiplier)
+        if on?
+          puts "ON! #{steps[0][:bri]} :: #{brightness} :: #{brightness > steps[0][:bri]}"
+          while brightness <= steps[0][:bri]
+            steps.shift
+          end
+        end
+        steps.each_with_index do |step, i|
+          update step.merge(on: true)
+          sleep(step[:transitiontime] / 10.0)
+        end
+        off
+      end
+
+      private
+
+
+      def sunrise_multiplier(total_time_in_minutes)
+        # total_time / 18 steps == time_per_step
+        # the multiplier should be 600 * time per step
+        minutes_per_step = total_time_in_minutes / 18.0
+        (minutes_per_step * 60 * 10).to_i
+      end
+
+      def sunrise_brightness
+        sun_bri_unit  = 10
+        SUN_STEPS.inject([0]){|all, i|  all << ((i * sun_bri_unit) + all[-1]).to_i } << 255
+      end
+
+      def sunrise_temps
+        sun_temp_unit = 16
+        SUN_STEPS.inject([500]){|all, i| all << (all[-1] - (i * sun_temp_unit)).to_i} << 200
+      end
+
+      def sunrise_times
+        [0, SUN_TIMES, 5].flatten
+      end
+
+      def sunset_times
+        [0, 5, SUN_TIMES.reverse].flatten
+      end
+
+      def sunrise_steps(multiplier = 600)
+        bri_steps = sunrise_brightness
+        tmp_steps = sunrise_temps
+
+        steps = []
+        sunrise_times.each_with_index do |t, i|
+          steps << {bri: bri_steps[i], ct: tmp_steps[i], transitiontime: (t * multiplier)}
+        end
+        steps
+      end
+
+      def sunset_steps(multiplier = 600)
+        bri_steps = sunrise_brightness.reverse
+        tmp_steps = sunrise_temps.reverse
+
+        steps = []
+        sunset_times.each_with_index do |t, i|
+          steps << {bri: bri_steps[i], ct: tmp_steps[i], transitiontime: (t * multiplier)}
+        end
+        steps
+      end
+
+    end
+  end
+end

data/lib/hue/bridge.rb

@@ -1,5 +1,6 @@
 require 'socket'
 require 'timeout'
+require 'logger'
 
 module Hue
   class Bridge
@@ -73,50 +74,44 @@ module Hue
     end
 
     def index(url)
-      request = Net::HTTP::Get.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
-      parse_and_check_response(Net::HTTP.new(url.host, url.port).start { |http| http.request(request) })
+      receive(Net::HTTP::Get, url)
     end
 
     def update(url, settings = {})
-      request = Net::HTTP::Put.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
-      request.body = settings.to_json
-      parse_and_check_response(Net::HTTP.new(url.host, url.port).start { |http| http.request(request) })
+      receive(Net::HTTP::Put, url, settings.to_json)
     end
 
     def delete(url, settings = {})
-      request = Net::HTTP::Delete.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
-      request.body = settings.to_json
-      parse_and_check_response(Net::HTTP.new(url.host, url.port).start{ |http| http.request(request) })
+      receive(Net::HTTP::Delete, url, settings.to_json)
     end
 
     def create(url, settings = {})
-      request = Net::HTTP::Post.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
-      request.body = settings.to_json
-      parse_and_check_response(Net::HTTP.new(url.host, url.port).start { |http| http.request(request) })
-    end
+      receive(Net::HTTP::Post, url, settings.to_json)
+    end
+
+    def receive(request_class, url, payload = nil)
+      request = request_class.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
+      request.body = payload if payload
+      Hue.logger.info("Sending #{payload.to_s if payload} to #{url.to_s}")
+      response = nil
+      begin
+        response = Net::HTTP.new(url.host, url.port).start { |http| http.request(request) }
+      rescue => err
+        Hue.logger.error(err.message)
+        raise Hue::Error.new("Problem reaching bridge.", err)
+      end
 
-    def parse_and_check_response(response)
-      if display(response)
+      if response && response.code.to_s != '200'
+        Hue.logger.info("Error with response #{response.code} #{response.message}")
+        raise Hue::Error.new("Unexpected response: #{response.code}, #{response.message}")
+      else
         json = JSON.parse(response.body)
+        Hue.logger.info("Response #{response.code} #{response.message}: #{json}")
         if json.is_a?(Array) && error = json.first['error']
           raise Hue::API::Error.new(error)
         else
           json
         end
-      else
-        raise Hue::Error.new("Unexpected response: #{response.code}, #{response.message}")
-      end
-    end
-
-    def display(response = nil)
-      if response and response.code.to_s != '200'
-        # Output to logger
-        # puts "Response #{response.code} #{response.message}: #{JSON.parse(response.body).first}"
-        false
-      else
-        # Output to logger
-        # puts "Response #{response.code} #{response.message}: #{JSON.parse(response.body).first}"
-        true
       end
     end
 

data/lib/hue/bulb.rb

@@ -1,6 +1,14 @@
+require_relative 'animations/candle'
+require_relative 'animations/sunrise'
+
 module Hue
   class Bulb
 
+    BRIGHTNESS_MAX = 255
+
+    include Animations::Candle
+    include Animations::Sunrise
+
     public
 
     attr_reader :id, :bridge
@@ -63,58 +71,39 @@ module Hue
     alias :bri :brightness
 
     def brightness=(bri)
-      update(bri: bri)
+      if scale = Hue.percent_to_unit_interval(bri)
+        update(bri: (scale * BRIGHTNESS_MAX).round)
+      else
+        update(bri: bri.to_i)
+      end
       brightness
     end
 
     alias :bri= :brightness=
 
-    def hue
-      self[:hue]
-    end
-
-    HUE_MAX = 65536.0
-    HUE_DEGREES = 360
-    HUE_SCALE = HUE_MAX / HUE_DEGREES
-
-    def hue=(_hue)
-      _hue = (_hue * HUE_SCALE).to_i
-      update(hue: _hue)
-      hue
+    def brightness_in_unit_interval
+      brightness / BRIGHTNESS_MAX.to_f
     end
 
-    def saturation
-      self[:sat]
+    def brightness_percent
+      (brightness_in_unit_interval * 100).round
     end
 
-    alias :sat :saturation
-
-    def saturation=(_sat)
-      update(sat: _sat)
-      sat
+    def color_mode
+      self[:colormode]
     end
 
-    alias :sat= :saturation=
+    alias :colormode :color_mode
 
-    def color_temperature
-      self[:ct]
+    def color
+      set_color
     end
 
-    alias :ct :color_temperature
-
-    def color_temperature=(_ct)
-      update(ct: [[_ct, 154].max, 500].min)
-      colortemp
+    def color=(col)
+      update(col.to_hash)
+      set_color
     end
 
-    alias :ct= :color_temperature=
-
-    def color_mode
-      self[:colormode]
-    end
-
-    alias :colormode :color_mode
-
     def blinking?
       !solid?
     end
@@ -146,312 +135,24 @@ module Hue
       self.options[:transitiontime] = (time * 10).to_i
     end
 
-    protected
-
-    def settings
-      options.merge case state['colormode']
-                    when 'ct'
-                      {'ct' => state['ct']}
-                    when 'xy'
-                      {'xy' => state['xy']}
-                    when 'hs'
-                      {'hue' => state['hue'], 'sat' => state['sat']}
-                    end.merge('on' => state['on'], 'bri' => state['bri'])
-    end
-
-    def rgb
-      send %(#{colormode}_to_rgb)
-    end
-
-    def red
-      rgb[:red]
-    end
-
-    def green
-      rgb[:green]
-    end
-
-    def blue
-      rgb[:blue]
-    end
-
-    def red=(_red)
-      self.rgb = [_red, green, blue]
-    end
-
-    def green=(_green)
-      self.rgb = [red, _green, blue]
-    end
-
-    def blue=(_blue)
-      self.rgb = [red, green, _blue]
-    end
-
-    def kelvin
-      # convert colortemp setting to Kelvin
-      1000000 / self['ct']
-    end
-
-    def kelvin=(_temp)
-      self.colortemp = 1000000 / [_temp, 1].max
-    end
-
-    def ct_to_rgb
-      # using method described at
-      # http://www.tannerhelland.com/4435/convert-temperature-rgb-algorithm-code/
-      temp = kelvin / 100
-
-      red = temp <= 66 ? 255 : 329.698727446 * ((temp - 60) ** -0.1332047592)
-
-      green = if temp <= 66
-                99.4708025861 * Math.log(temp) - 161.1195681661
-              else
-                288.1221695283 * ((temp - 60) ** -0.0755148492)
-              end
-
-      blue = if temp >= 66
-                255
-              elsif temp <= 19
-                0
-              else
-                138.5177312231 * Math.log(temp - 10) - 305.0447927307
-              end
-
-      {   red: [[red,   0].max, 255].min.to_i,
-        green: [[green, 0].max, 255].min.to_i,
-         blue: [[blue,  0].max, 255].min.to_i
-      }
-
-    end
-
-    def xyz
-      vals = state['xy']
-      vals + [1 - vals.first - vals.last]
-    end
-
-    def xy_to_rgb
-      values = (RGB_MATRIX * Matrix[xyz].transpose).to_a.flatten.map{|x| [[x * 255, 0].max, 255].min.to_i}
-      {   red: values[0],
-        green: values[1],
-         blue: values[2]
-      }
-    end
-
-    def hue_in_degrees
-      self['hue'].to_f / HUE_SCALE
-    end
-
-    def hue_as_decimal
-      hue_in_degrees / HUE_DEGREES
-    end
-
-    def sat_as_decimal
-      self['sat'] / 255.0
-    end
-
-    def brightness_as_decimal
-      brightness / 255.0
-    end
-
-    def hs_to_rgb
-      h, s, v = hue_as_decimal, sat_as_decimal, brightness_as_decimal
-      if s == 0 #monochromatic
-        red = green = blue = v
-      else
-
-        v = 1.0 # We are setting the value to 1. Don't count brightness here
-        i = (h * 6).floor
-        f = h * 6 - i
-        p = v * (1 - s)
-        q = v * (1 - f * s)
-        t = v * (1 - (1 - f) * s)
-
-        case i % 6
-        when 0
-          red, green, blue = v, t, p
-        when 1
-          red, green, blue = q, v, p
-        when 2
-          red, green, blue = p, v, t
-        when 3
-          red, green, blue = p, q, v
-        when 4
-          red, green, blue = t, p, v
-        when 5
-          red, green, blue = v, p, q
-        end
-      end
-
-      {   red: [[red * 255,   0].max, 255].min.to_i,
-        green: [[green * 255, 0].max, 255].min.to_i,
-         blue: [[blue * 255,  0].max, 255].min.to_i
-      }
-    end
-
-    def rgb=(colors)
-      red, green, blue = colors[0] / 255.0, colors[1] / 255.0, colors[2] / 255.0
-
-      max = [red, green, blue].max
-      min = [red, green, blue].min
-      h, s, l = 0, 0, ((max + min) / 2 * 255)
-
-      d = max - min
-      s = max == 0 ? 0 : (d / max * 255)
-
-      h = case max
-          when min
-            0 # monochromatic
-          when red
-            (green - blue) / d + (green < blue ? 6 : 0)
-          when green
-            (blue - red) / d + 2
-          when blue
-            (red - green) / d + 4
-          end * 60  # / 6 * 360
-
-      h = (h * HUE_SCALE).to_i
-      update hue: h, sat: s.to_i#, bri: l.to_i
-      [h, s, 1.0]
-    end
-
-    def candle(repeat = 15)
-      # 0-65536 for hue, 182 per deg. Ideal 30-60 deg (5460-10920)
-      stash!
-      on if off?
-
-      repeat.times do
-        hue = ((rand * 3460) + 5460).to_i
-        sat = rand(64) + 170
-        bri = rand(32) + 16
-
-        delay = (rand * 0.35) + (@delay ||= 0)
-        update(hue: hue, sat: sat, bri: bri, transitiontime: (delay * 10).to_i)
-        sleep delay
-      end
-      restore!
-    end
-
     private
 
-    def stash!
-      @stash ||= settings
-    end
-
-    def restore!
-      if stash
-        update(@stash)
-        unstash!
-      end
-    end
-
-    def unstash!
-      @stash = nil
-    end
-
     def status
       @status || refresh!
     end
 
-    def update(settings = {})
-      if bridge.set_light_state(id, options.merge(settings))
-        settings.each do |key, value|
-          @status['state'][key.to_s] = value # or refresh!
-        end
-      end
+    def set_color
+      @color = Colors.parse_state(state)
     end
 
-    # Experimental Sunrise/Sunset  action
-    # this will transition from off and warm light to on and daytime light
-    # in a curve that mimics the actual sunrise.
-
-    def perform_sunrise(total_time_in_minutes = 18)
-      # total_time / 18 steps == time_per_step
-      # the multiplier should be 600 * time per step
-      minutes_per_step = total_time_in_minutes / 18.0
-      multiplier = (minutes_per_step * 60 * 10).to_i
-
-      perform_sun_transition total_time_in_minutes, sunrise_steps(multiplier)
-    end
-
-    def perform_sunrise(total_time_in_minutes = 18)
-      multiplier = sunrise_multiplier total_time_in_minutes
-      steps = sunrise_steps(multiplier)
-      if on?
-        puts "ON! #{steps[0][:bri]} :: #{brightness} :: #{brightness > steps[0][:bri]}"
-        while brightness >= steps[0][:bri]
-          steps.shift
-        end
-      end
-      steps.each_with_index do |step, i|
-        update step.merge(on: true)
-        sleep(step[:transitiontime] / 10.0)
-      end
-    end
-
-    def perform_sunset(total_time_in_minutes = 18)
-      multiplier = sunrise_multiplier total_time_in_minutes
-      steps = sunset_steps(multiplier)
-      if on?
-        puts "ON! #{steps[0][:bri]} :: #{brightness} :: #{brightness > steps[0][:bri]}"
-        while brightness <= steps[0][:bri]
-          steps.shift
+    def update(settings = {})
+      if bridge.set_light_state(id, options.merge(settings))
+        if @status
+          settings.each do |key, value|
+            @status['state'][key.to_s] = value # or refresh!
+          end
         end
       end
-      steps.each_with_index do |step, i|
-        update step.merge(on: true)
-        sleep(step[:transitiontime] / 10.0)
-      end
-      off
-    end
-
-    SUN_STEPS = [ 1.5, 2, 3, 1, 4, 2.5 ]
-    SUN_TIMES = [ 3,   3, 3, 1, 2, 1]
-
-    def sunrise_multiplier(total_time_in_minutes)
-      # total_time / 18 steps == time_per_step
-      # the multiplier should be 600 * time per step
-      minutes_per_step = total_time_in_minutes / 18.0
-      (minutes_per_step * 60 * 10).to_i
-    end
-
-    def sunrise_brightness
-      sun_bri_unit  = 10
-      SUN_STEPS.inject([0]){|all, i|  all << ((i * sun_bri_unit) + all[-1]).to_i } << 255
-    end
-
-    def sunrise_temps
-      sun_temp_unit = 16
-      SUN_STEPS.inject([500]){|all, i| all << (all[-1] - (i * sun_temp_unit)).to_i} << 200
-    end
-
-    def sunrise_times
-      [0, SUN_TIMES, 5].flatten
-    end
-
-    def sunset_times
-      [0, 5, SUN_TIMES.reverse].flatten
-    end
-
-    def sunrise_steps(multiplier = 600)
-      bri_steps = sunrise_brightness
-      tmp_steps = sunrise_temps
-
-      steps = []
-      sunrise_times.each_with_index do |t, i|
-        steps << {bri: bri_steps[i], ct: tmp_steps[i], transitiontime: (t * multiplier)}
-      end
-      steps
-    end
-
-    def sunset_steps(multiplier = 600)
-      bri_steps = sunrise_brightness.reverse
-      tmp_steps = sunrise_temps.reverse
-
-      steps = []
-      sunset_times.each_with_index do |t, i|
-        steps << {bri: bri_steps[i], ct: tmp_steps[i], transitiontime: (t * multiplier)}
-      end
-      steps
     end
 
   end