hue-lib 0.5.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,88 @@
+RubyHue
+================
+
+This is a very early attempt to create a Ruby library for controlling the [Philips Hue](http://www.meethue.com) lighting system. The API has not yet been released, but there are [several](http://www.nerdblog.com/2012/10/a-day-with-philips-hue.html) [people](http://rsmck.co.uk/hue) working to figure it out.
+
+# WARNING
+All of this is very experimental and could permanently damage your awesome (but ridiculously expensive) lightbulbs. As such, exercise extreme caution.
+
+## Getting Started
+You can get a [great overview](http://rsmck.co.uk/hue) of the options and limitations of the lights from Ross McKillop.
+
+You will need to find the IP address of your bridge unit and also generate a unique ID (UUID works great) for your controlling application and add them to the top of the `hue.rb` file.
+
+You will need to use this information to register your app with the controller. This library does not do that at this time, so you will need to manually do that. I suggest following the *Registering Your Application* section of [Ross's overview](http://rsmck.co.uk/hue).
+
+## Usage
+To begin using, fire up the irb console and load the `hue.rb` file.
+
+```ruby
+>> load 'hue.rb'
+=> true
+```
+
+You can see all of the lights attached to your controller by querying the bridge.
+
+```ruby
+>> Hue::Bridge.identities
+=> {"1"=>"Master Bedroom Dresser", "2"=>"Wife Bedside", "3"=>"Bedside (front)", "4"=>"Bedside (back)", "5"=>"Family Room Desk", "6"=>"Family Room", "7"=>"Living Room Square"}
+```
+
+If you know the ID number of a particular lamp, you can access it directly.
+
+```ruby
+>> b = Hue::Bulb.new(5)
+=> #<Hue::Bulb:0x007fe35a3586b8 @id=5, @hub=#<Hue::Bridge:0x007fe35a358690 @light_id="5">>
+
+# on/off
+>> b.on?
+=> false
+
+>> b.on
+=> true
+
+>> b.on?
+=> true
+
+# settings
+>> b.settings
+=> {"ct"=>343, "on"=>true, "bri"=>240}
+
+>> b.brightness = 128
+=> 128
+
+>> b.update hue: 45000, sat: 180
+=> true
+
+>> b.settings
+=> {"hue"=>45000, "sat"=>180, "on"=>true, "bri"=>128}
+
+# blinking
+>> b.blinking?
+=> false
+
+>> b.blink
+=> nil
+
+>> b.blinking?
+=> true
+
+>> b.blink false
+=> nil
+
+>> b.blinking?
+=> false
+```
+
+## Experimental
+There is an experimental mode that attempts to simulate a candle flicker. This defaults to only flickering 15 times as it's really not the way the bridge or bulbs were designed to work. Additionally, this operates on the main thread so you really can't do anything else while it's running.
+
+```ruby
+>> b.candle
+=> nil
+```
+
+The candle makes use of temporarily stashing the lamp's current settings before it starts and then restoring them upon completion. You can use this yourself with the `stash` and `restore` commands.
+
+## Going Forward
+There is still a lot of work to be done figuring out the various timer options of the hub, etc. Hopefully, the official API will be released in the near future and expose even more goodies that we're unaware of.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new('spec') do |t|
+    t.rspec_opts = ["-fd", "-c"]
+    t.ruby_opts = ["-Ispec,lib"]
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+
+rescue LoadError
+  desc 'Spec rake task not available'
+  task :spec do
+    abort 'Spec rake task is not available. Be sure to install rspec as a gem or plugin'
+  end
+end
+
+task :default => [:spec]

data/hue-lib.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "hue-lib"
+  s.version     = '0.5.0'
+  s.authors     = ["Birkir A. Barkarson", ""]
+  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.rubyforge_project = "hue-lib"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency("json")
+  s.add_development_dependency("rspec", '>= 2.6.0')
+  s.add_development_dependency("mocha", '>= 0.9.0')
+  s.add_development_dependency("webmock", '>= 1.8.0')
+end

data/lib/hue.rb

@@ -0,0 +1,59 @@
+APP_NAME = 'ruby_hue'
+BASE    = 'http://10.10.10.20/api'
+# UUID    = 'd79713a3433df3d972ba7c22cb1cc23e'
+# Digest::MD5.hexdigest('aa4f6bc0-2045-0130-8cf0-0018de9ecdd0')
+
+require 'net/http'
+require 'json'
+require 'matrix'
+
+RGB_MATRIX = Matrix[
+  [3.233358361244897, -1.5262682428425947, 0.27916711262124544],
+  [-0.8268442148395835, 2.466767560486707, 0.3323241608108406],
+  [0.12942207487871885, 0.19839858329512317, 2.0280912276039635]
+]
+
+require 'hue/bridge.rb'
+require 'hue/bulb.rb'
+require 'hue/config.rb'
+
+module Hue
+
+  DEVICE_TYPE = "RubyHue"
+
+  def self.device_type
+    DEVICE_TYPE
+  end
+
+  def self.config
+    Hue::Config.default
+  end
+
+  class Error < StandardError
+    attr_accessor :original_error
+
+    def initialize(message, original_error = nil)
+      super(message)
+      @original_error = original_error
+    end
+
+    def to_s
+      if @original_error.nil?
+        super
+      else
+        "#{super}\nCause: #{@original_error.to_s}"
+      end
+    end
+  end
+
+  module API
+    class Error < ::Hue::Error
+      def initialize(api_error)
+        @type = api_error['type']
+        @address = api_error['address']
+        super(api_error['description'])
+      end
+    end
+  end
+
+end

data/lib/hue/bridge.rb

@@ -0,0 +1,147 @@
+require 'digest/md5'
+require 'uuid'
+# require 'singleton'
+
+module Hue
+  class Bridge
+    # include Singleton
+
+    # # Remove
+    # def self.method_missing(method, *args, &block)
+    #   if args.empty?
+    #     self.instance.send method
+    #   else
+    #     self.instance.send method, *args
+    #   end
+    # end
+
+    # Move to APP class
+    def self.register(host = BASE)
+      # TODO: Look for default config.
+      puts "Please press the button on bridge before continuing."
+      puts "Once done, press Enter to continue."
+      gets
+      secret = Digest::MD5.hexdigest(UUID.generate) # one time UUID
+      puts "Registering app...(#{secret})"
+      config = Hue::Config.new(host, secret)
+      instance.create(
+        URI.parse(config.base_uri),
+        {"username" => config.base_uri, "devicetype" => Hue.device_type}
+      )
+      config.write
+    end
+
+    # Move to APP class
+    def self.remove
+      config = Config.default
+      instance.delete(
+        URI.parse(config.base_uri),
+        {"username" => config.identifier}
+      )
+      config.delete
+    end
+
+    public
+
+    attr_reader :hue_config
+
+    def initialize(hue_config = Hue.config)
+      @hue_config = hue_config
+    end
+
+    def status
+      index(uri)
+    end
+
+    def lights
+      index(uri('lights'))
+    end
+
+    def light_names
+      lights.map { |k,v| "#{k}. #{v['name']}" }.join("\n")
+    end
+
+    def config
+      index(uri('config'))
+    end
+
+    def schedules
+      index(uri('schedules'))
+    end
+
+    def bulbs
+      # puts status['lights'].inspect
+      @bulbs ||= lights.keys.map { |b| Bulb.new(self, b) }
+    end
+
+    # def remove_schedule(schedule_id)
+    #   delete uri('schedules', schedule_id)
+    #   puts "Removed schedule #{schedule_id}"
+    # end
+
+    # def remove_all_schedules
+    #   ids = schedules.keys.map(&:to_i).sort.reverse
+    #   puts "Removing #{ids.size} schedule#{'s' if ids.size != 1}..."
+    #   ids.each{|x| remove_schedule x}
+    # end
+
+    def get_light_state(id)
+      index(uri('lights', id))
+    end
+
+    def set_light_state(id, state)
+      update(uri('lights', id, 'state'), state)
+    end
+
+    private
+
+    def uri(*args)
+      URI [hue_config.base_uri, hue_config.identifier, args].flatten.reject{|x| x.to_s.strip == ''}.join('/')
+    end
+
+    def index(url)
+      # json = Net::HTTP.get(url)
+      # JSON.parse(json)
+      request = Net::HTTP::Get.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
+      response = Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
+      display(response)
+      json = JSON.parse(response.body)
+      if json.is_a?(Array) && error = json.first['error']
+        raise Hue::API::Error.new(error)
+      else
+        json
+      end
+    end
+
+    def update(url, settings = {})
+      request = Net::HTTP::Put.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
+      request.body = settings.to_json
+      display Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
+    end
+
+    def delete(url, settings = {})
+      request = Net::HTTP::Delete.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
+      request.body = settings.to_json
+      display Net::HTTP.new(url.host, url.port).start{|http| http.request(request)}
+    end
+
+    def create(url, settings = {})
+      request = Net::HTTP::Post.new(url.request_uri, initheader = {'Content-Type' =>'application/json'})
+      request.body = settings.to_json
+      display Net::HTTP.new(url.host, url.port).start {|http| http.request(request) }
+    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
+
+  end
+end

data/lib/hue/bulb.rb

@@ -0,0 +1,458 @@
+module Hue
+  class Bulb
+
+    public
+
+    attr_reader :id, :bridge
+    attr_accessor :options
+
+    def initialize(bridge, light_id, options = {})
+      @bridge = bridge
+      @id = light_id
+      @options = options
+    end
+
+    def refresh!
+      @status = bridge.get_light_state(id)
+    end
+
+    def info
+      status.select do |k, value|
+        value.is_a?(String)
+      end
+    end
+
+    def state
+      status['state']
+    end
+
+    def [](item)
+      state[item.to_s]
+    end
+
+    def name
+      status['name']
+    end
+
+    def name=(_name)
+      update(name: _name)
+    end
+
+    def on?
+      self[:on]
+    end
+
+    def off?
+      !on?
+    end
+
+    def on
+      update(on: true)
+      on?
+    end
+
+    def off
+      update(on: false)
+      off?
+    end
+
+    def brightness
+      self[:bri]
+    end
+
+    alias :bri :brightness
+
+    def brightness=(bri)
+      update(bri: bri)
+      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
+    end
+
+    def saturation
+      self[:sat]
+    end
+
+    alias :sat :saturation
+
+    def saturation=(_sat)
+      update(sat: _sat)
+      sat
+    end
+
+    alias :sat= :saturation=
+
+    def color_temperature
+      self[:ct]
+    end
+
+    alias :ct :color_temperature
+
+    def color_temperature=(_ct)
+      update(ct: [[_ct, 154].max, 500].min)
+      colortemp
+    end
+
+    alias :ct= :color_temperature=
+
+    def color_mode
+      self[:colormode]
+    end
+
+    alias :colormode :color_mode
+
+    def blinking?
+      !solid?
+    end
+
+    def solid?
+      'none' == self['alert']
+    end
+
+    def blink
+      update(alert: 'lselect')
+    end
+
+    def solid
+      update(alert: 'none')
+    end
+
+    def flash
+      update(alert: 'select')
+      update(alert: 'none')
+    end
+
+    def transition_time
+      # transition time in seconds
+      (options[:transitiontime] || 1).to_f / 10
+    end
+
+    def transition_time=(time)
+      # transition time in seconds
+      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
+    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
+        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
+end