trigger_switch_d 0.1.1 → 0.1.2

data/lib/trigger_switch_d/daylight.rb

@@ -20,23 +20,9 @@
 # http://users.electromagnetic.net/bu/astro/sunrise-set.php (accessed 2010-03-02)
 # http://www.astro.uu.nl/~strous/AA/en/reken/zonpositie.html (accessed 2010-03-02)
 
-module Daylight #:nodoc:all
+require "time"
 
-  JULIAN_DAYS_UNTIL_YEAR_2000 = 2451545.0
-  UNIT_CIRCLE = 360.0
-  C1 = 0.0009
-  C2 = 357.5291
-  C3 = 0.98560028
-  C4 = 1.9148
-  C5 = 0.0200
-  C6 = 0.0003
-  C7 = 102.9372
-  C8 = 0.0053
-  C9 = 0.0069
-  C10 = 23.45
-  C11 = -0.83
-  FOR = {:sunrise => -1, :sunset => 1}
-  
+module Daylight #:nodoc:all
   def self.extended(receiver)
     days = receiver.jd
     raise "method jd on #{receiver} does not return Fixnum" unless days.kind_of? Fixnum
@@ -52,48 +38,143 @@ module Daylight #:nodoc:all
   
   private
   
-  def time_for(what_time,at_location)
-    __prepare_float__
-    n = ((days_since_2000 - C1) - per_unit_circle(at_location[:west])).round
-    j  = JULIAN_DAYS_UNTIL_YEAR_2000 + C1 + (per_unit_circle(at_location[:west])) + n
-    
-    transit_approx = stable_transit_approximation(j)
-    
-    declination = Math.asin(Math.sin(transit_approx[:lamda].to_rad) * Math.sin(C10.to_rad)).to_degrees
-    h = (Math.acos((Math.sin(C11.to_rad) - Math.sin(at_location[:north].to_rad)*Math.sin(declination.to_rad))/(Math.cos(at_location[:north].to_rad) * Math.cos(declination.to_rad)))).to_degrees
-    j2 = JULIAN_DAYS_UNTIL_YEAR_2000 + C1 + per_unit_circle(FOR[what_time]*h + at_location[:west]) + n
-    raw = j2 + (C8 * Math.sin(transit_approx[:m].to_rad)) - (C9 * Math.sin(2*transit_approx[:lamda].to_rad))
-    dt = DateTime.jd(raw).new_offset(0.5)
-    Time.utc(dt.year,dt.month,dt.day,dt.hour,dt.min,dt.sec,0)
-  end
+  JULIAN_DAYS_UNTIL_YEAR_2000 = 2451545.0
+  UNIT_CIRCLE = 360.0
+  C1 = 0.0009
+  C8 = 0.0053
+  C9 = 0.0069
+  FOR = {:sunrise => -1, :sunset => 1}
 
-  def stable_transit_approximation(j)
-    transit_approx = transit_approximation(j,j)
-    count = 5
-    until((transit_approx == (transit_approx = transit_approximation(j,transit_approx[:transit]))) || count <= 0)
-      count -= 1 
+  # Calculates declination of earth
+  class DeclinationOfEarth #:nodoc:all
+    Obliquity_of_the_Ecliptic_for_Earth_in_rad = 23.45 * Math::PI/180.0
+    def initialize(angle_as_rad)
+      @declination = Math.asin(Math.sin(angle_as_rad) * Math.sin(Obliquity_of_the_Ecliptic_for_Earth_in_rad))
+    end
+    def to_f
+      @declination
     end
-    transit_approx
   end
   
-  def transit_approximation(j,transit)
-    m = mod_unit_circle(C2 + C3 * (transit - JULIAN_DAYS_UNTIL_YEAR_2000))
-    c = (C4 * Math.sin(m.to_rad)) + (C5 * Math.sin(2 * m.to_rad)) + (C6 * Math.sin(3 * m.to_rad))
-    lamda = mod_unit_circle(m + C7 + c + UNIT_CIRCLE/2)
-    transit = j + (C8 * Math.sin(m.to_rad)) - (C9 * Math.sin(2 * lamda.to_rad))
-    {:m => m, :lamda => lamda, :transit => transit}
-  end  
-
-  def days_since_2000
-    self.jd - JULIAN_DAYS_UNTIL_YEAR_2000
+  # Holds angle ratio per degree
+  class AngleRatio #:nodoc:all
+    def initialize(angle)
+      @ratio = angle.to_f/360.0
+    end
+    def to_f
+      @ratio
+    end
   end
   
-  def per_unit_circle(value)
-    value / UNIT_CIRCLE
+  #Equation of Center for Earth
+  class EquationOfCenterForEarth #:nodoc:all
+    COEFFICIENTS = [1.9148, 0.0200, 0.0003]
+    def initialize(mean_anomaly_as_rad)
+      sum = 0
+      COEFFICIENTS.each_with_index do |coefficient, multiplier|
+        sum += coefficient * Math.sin((multiplier + 1) * mean_anomaly_as_rad)
+      end
+      @center = sum
+    end
+    def to_f
+      @center
+    end
+  end
+  
+  #Hour Angle for observer in degrees
+  class HourAngleForObserver #:nodoc:all
+    Solar_Disk_Diameter_and_Refraction_for_Earth_as_rad = -0.83 * Math::PI/180.0
+    def initialize(north_as_rad, transit)
+      declination = DeclinationOfEarth.new(transit.lamda.to_rad)
+      hour_angle_numerator = Math.sin(Solar_Disk_Diameter_and_Refraction_for_Earth_as_rad) - Math.sin(north_as_rad)*Math.sin(declination)
+      hour_angle_denominator = Math.cos(north_as_rad) * Math.cos(declination)
+      @hour_angle = Math.acos(hour_angle_numerator/hour_angle_denominator).to_degrees
+    end
+    def to_f
+      @hour_angle
+    end
   end
   
-  def mod_unit_circle(value)
-    value % UNIT_CIRCLE
+  #Calculates new transit, by calling step a number of times to improve the approximation
+  class Transit #:nodoc:all
+    
+    attr_reader :lamda
+    def initialize(west,north,date)
+      @north = north
+      # @what_time = what_time
+      @julian_date = JulianDateApproximation.new(west,date)
+      @approximation = transit_approximation(@julian_date.to_f)
+      @mean_anomaly, @lamda, @julian_date_transit_approximation_as_float = @approximation
+      run
+    end
+    
+    def to_utc(what_time)
+      @julian_date.hour_angle = FOR[what_time]*Float(HourAngleForObserver.new(@north.to_rad, self))
+      raw = Float(@julian_date) + (C8 * Math.sin(@mean_anomaly)) - (C9 * Math.sin(2*@lamda.to_rad))
+      dt = Date.jd(raw+0.5)
+      Time.httpdate(dt.strftime("%a, %d %b %Y %H:%M:%S GMT"))
+    end
+    
+    private
+    def run
+      number_of_approximations_to_go = 5
+      while (this_is_not_the_best_approximation?(new_approximation = transit_approximation(@julian_date_transit_approximation_as_float - JULIAN_DAYS_UNTIL_YEAR_2000)) || number_of_approximations_to_go == 0)
+        @approximation = new_approximation
+        @mean_anomaly, @lamda, @julian_date_transit_approximation_as_float = @approximation
+        number_of_approximations_to_go -= 1
+      end
+    end
+    
+    def this_is_not_the_best_approximation?(new_approximation)
+      @approximation != new_approximation
+    end
+    
+    def transit_approximation(julian_date_transit_approximation_as_float)
+      mean_anomaly = (357.5291 + 0.98560028 * julian_date_transit_approximation_as_float) % UNIT_CIRCLE
+      __new_transit__(__lamda__(mean_anomaly.to_rad))
+    end
+    
+    def __new_transit__(m_lamda)
+      mean_anomaly, lamda = m_lamda
+      transit = (@julian_date.to_f + (C8 * Math.sin(mean_anomaly)) - (C9 * Math.sin(2 * lamda.to_rad)))
+      [mean_anomaly, lamda, transit]
+    end
+
+    def __lamda__(mean_anomaly)
+      center = Float(EquationOfCenterForEarth.new(mean_anomaly))
+      lamda = (mean_anomaly.to_degrees + center + 360.0/2 + 102.9372)
+      [mean_anomaly, lamda % UNIT_CIRCLE]
+    end
+  end
+    
+  #Julian date approximation by observer westerly location
+  class JulianDateApproximation #:nodoc:all
+    attr_accessor :hour_angle
+    def initialize(west,date)
+      @date = date
+      @west = west
+      @approximation = approximate(@west,@date)
+    end
+    def hour_angle=(angle)
+      @approximation = approximate(@west, @date, angle)
+    end
+    
+    def to_f
+      @approximation
+    end
+    
+    private
+    
+    def approximate(west, date, hour_angle=0)
+      number = ((date.jd - JULIAN_DAYS_UNTIL_YEAR_2000 - C1) - Float(AngleRatio.new(west))).round
+      JULIAN_DAYS_UNTIL_YEAR_2000 + C1 + Float(AngleRatio.new(west + hour_angle)) + number
+    end
+    
+  end
+    
+  def time_for(what_time,at_location)
+    __prepare_float__
+    Transit.new(at_location[:west],at_location[:north],self).to_utc(what_time)
   end
 
   def __prepare_float__
@@ -103,11 +184,13 @@ module Daylight #:nodoc:all
   end
   
   module DayFloat
+    D180_PI = 180.0/Math::PI
+    PI_D180 = Math::PI/180.0
     def to_rad
-      self * Math::PI/180.0
+      self * PI_D180
     end
     def to_degrees
-      self * 180.0/Math::PI
+      self * D180_PI
     end
   end
   

data/lib/trigger_switch_d/ipc.rb

@@ -16,24 +16,56 @@
 
 module TriggerSwitchD
   module IPC
-    
     #unix socket thread, see README.rdoc for usage
     def self.create(socket_path)
       File.delete(socket_path) if File.exist? socket_path
       sock = UNIXServer.open(socket_path)
       Thread.start(sock) do |sock|
-        while(!["stop"].include?(Thread.current["received"]))
-          Thread.current["received"] = ""
-          s1 = sock.accept
-          while(!["stop","bye"].include?(Thread.current["received"]))
-            Thread.current["received"] = s1.recvfrom(200)[0]
-            Thread.current["response"] = Thread.current["received"] if Thread.current["received"] == "bye"
-            Thread.stop if !["bye",""].include?(Thread.current["received"])
-            s1.send(Thread.current["response"],0) unless Thread.current["received"] == ""
-            Thread.current["received"] = "bye" if Thread.current["received"] == ""
-          end
-        end
+        outer_loop(sock)
+      end
+    end
+    
+    private
+    
+    def self.outer_loop(sock)
+      current_thread = Thread.current
+      while(!["stop"].include?(current_thread["received"]))
+        current_thread["received"] = ""
+        accepted_socket = sock.accept
+        inner_loop(accepted_socket)
+      end
+    end
+
+    def self.inner_loop(sock)
+      current_thread = Thread.current
+      while(!["stop","bye"].include?(current_thread["received"]))
+        wait_and_receive_from(sock)
+        wait_for_command_to_process
+        send_response(sock)
+        receive_connection_lost
       end
     end
+    
+    def self.receive_connection_lost
+      current_thread = Thread.current
+      current_thread["received"] = "bye" if current_thread["received"] == ""
+    end
+    
+    def self.send_response(sock)
+      current_thread = Thread.current
+      sock.send(current_thread["response"],0) unless current_thread["received"] == ""
+    end
+    
+    def self.wait_and_receive_from(sock)
+      current_thread = Thread.current
+      current_thread["received"] = sock.recvfrom(200)[0]
+    end
+    
+    def self.wait_for_command_to_process
+      current_thread = Thread.current
+      received_str = current_thread["received"]
+      Thread.stop unless ["bye",""].include?(received_str)
+      current_thread["response"] = "bye" if received_str == "bye"
+    end
   end
 end

data/lib/trigger_switch_d/schedule.rb

@@ -24,7 +24,7 @@ module TriggerSwitchD
   module Schedule  
     module InstanceMethods
       def schedule_action(action)
-        self._insert_action_(action) if find(action.to_s) == nil
+        self.__insert_action__(action)
         find(action.to_s)
       end
       
@@ -42,7 +42,7 @@ module TriggerSwitchD
         end_of_day = "23:59:59"
         return end_of_day unless hour_minute =~ /\d{2}:\d{2}/
         time = Time.parse(hour_minute)
-        cronological.keys.sort {|x,y| Time.parse(x) <=> Time.parse(y)}.find(Proc.new {end_of_day}) do |at|
+        cronological.keys.sort {|first,second| Time.parse(first) <=> Time.parse(second)}.find(Proc.new {end_of_day}) do |at|
           time < Time.parse(at)
         end
       end
@@ -55,8 +55,9 @@ module TriggerSwitchD
 
       #Executes action and removes it from the schedule
       def execute(at,output)
-        cronological[at].values.each { |action| action.execute(output) } unless cronological[at] == nil
-        self._remove_executed_actions_from_schedule_(at)
+        cronolog_at = cronological[at]
+        cronolog_at.values.each { |action| action.execute(output) } unless cronolog_at == nil
+        self.__remove_executed_actions_from_schedule__(at)
       end
 
       #Hash of actions accessible by "HH:MM" format
@@ -69,25 +70,31 @@ module TriggerSwitchD
         self[:all]
       end
 
-      def _remove_executed_actions_from_schedule_(at) #:nodoc:
-        cronological[at].values.clone.each do |element|
+      def __remove_executed_actions_from_schedule__(at) #:nodoc:
+        cronolog = cronological
+        cronolog_at = cronolog[at]
+        cronolog_at.values.clone.each do |element|
           by_name.delete(element.to_s)
-        end unless cronological[at] == nil
-        cronological.delete(at)
+        end unless cronolog_at == nil
+        cronolog.delete(at)
       end
 
-      def _insert_action_(action) #:nodoc:
+      def __insert_action__(action) #:nodoc:
+        return if __action_is_scheduled__(action)
         name = action.to_s
         by_name[name] = action
-        cronological[action.at] ||= {}
-        cronological[action.at][name] = by_name[name]
+        cronolog_at = cronological[action.at] ||= {}
+        cronolog_at[name] = action
+      end
+      
+      def __action_is_scheduled__(action)
+        by_name.keys.include?(action.to_s)
       end
     end
     
     #Creates an instance of a schedule
     def create
-      schedule = {:all => {}, :cronological => {}}
-      schedule.extend InstanceMethods
+      schedule = {:all => {}, :cronological => {}}.extend InstanceMethods
     end
     
     module_function :create

data/lib/trigger_switch_d/switch.rb

@@ -28,6 +28,12 @@ module TriggerSwitchD
             instance_variable_set("@"+key.to_s,value) if respond_to?(key)
           end
         end
+        
+        def to_a_by_keys(keys)
+          keys.map do |key|
+            send(key)
+          end
+        end
       end
       EOS
       ::TriggerSwitchD.module_eval(definition)

data/lib/trigger_switch_d/trigger_switch_d_helper.rb

@@ -18,27 +18,28 @@
 module TriggerSwitchD
   
   #Loads up schedule with the actions in file
-  def load_scheduled_actions(file,schedule,devices,environment,date=Date.today)
+  def self.load_scheduled_actions(file,date=Date.today)
     rows = file.readlines
     rows.each do |code_line|
-      action = Action.new(code_line,devices,environment,date)
-      schedule.schedule_action(action) #unless Time.parse(action.at) < Time.now
+      yield(code_line, date)
     end
   end
   
   #Returns devices loaded from file
-  def load_devices(file)
+  def self.load_devices(file)
     devices = YAML::load(file)
     SwitchFactory.new(devices[0]["switches"][0].keys)
-    result = {}
-    devices.each do |device|
-      switches = device["switches"].map do |switch|
-        TriggerSwitchD::Switch.new(switch)
-      end
-      result[device["name"]] = switches
+    devices.inject({}) do |result, device|
+      result[device["name"]] = TriggerSwitchD::map_switches(device["switches"])
+      result
     end
-    result
   end
-
-  module_function :load_scheduled_actions, :load_devices
+  
+  private 
+  
+  def self.map_switches(pre_switches) #:nodoc
+    pre_switches.map do |switch|
+      TriggerSwitchD::Switch.new(switch)
+    end    
+  end
 end

data/samples/devices

@@ -0,0 +1,14 @@
+--- 
+- name: "källare"
+  switches: 
+  - unit_code: "3"
+    house_code: A
+    model_name: plain_text
+  - unit_code: "4"
+    house_code: A
+    model_name: plain_text
+- name: "yttertrapp"
+  switches: 
+  - unit_code: "5"
+    house_code: A
+    model_name: plain_text

data/samples/devices.rising_sun

@@ -0,0 +1,6 @@
+--- 
+- name: "ovanvåning"
+  switches: 
+  - unit_code: "2"
+    house_code: "4"
+    model_name: rising_sun

data/samples/environment.rb

@@ -0,0 +1,44 @@
+# TriggerSwitchD, executes commands to activate/deactive remote switches.
+# (c) Copyright 2010 Pontus Strömdahl, AdhocSkill. 
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#longitude and latitude for Malmö, Sweden. decimal form
+Config.geo_position = {:north => 54.57525, :west => -12.94125}
+
+#Paths: base for files tsd.log, devices, scheduled_actions and lookup.dsl (leave alone if uncertain) 
+#       If you use vcp set vcp_port to your device, it should look like the example with a serial
+#       number instead of the xxxxxxxx
+Config.log_path = "~/.trigger_switch_d/log"
+Config.db_path = "~/.trigger_switch_d/db"
+Config.dsl_path = "config"
+# Config.vcp_port = "/dev/tty.usbserial-xxxxxxxx"
+
+#Log: can be one of :file, :development or :spec (:spec is for the rspecs, ie don't use)
+#     when log_object is set to :file, the log is written to tsd.log (log_path + /tsd.log)
+#     when log_object is set to :development the log is written to STDOUT, useful for debugging
+# Config.log_object = :file
+Config.log_object = :development
+# Config.log_object = :spec
+
+#Output: can be one of :development, :tellstick or :spec (:spec is for the rspecs, ie don't use)
+#        when output is set to :development output is written to STDOUT, useful for debugging
+#        when output is set to :vcp output is sent to the usb port that has a virtual com port 
+# Config.output = :vcp
+Config.output = :development
+# Config.output = :spec
+
+#Unix socket: (leave alone if uncertain)
+Config.unix_socket_path = "/tmp"

data/samples/lookup.dsl

@@ -0,0 +1,7 @@
+--- 
+släck: deactivate
+klockan: at
+solnedgång: sunset
+vid: at
+soluppgång: sunrise
+tänd: activate

data/samples/scheduled_actions

@@ -0,0 +1,6 @@
+tänd källare vid solnedgång
+släck källare klockan 00:15
+tänd källare klockan 04:00
+släck källare vid soluppgång
+tänd yttertrapp vid solnedgång
+släck yttertrapp vid soluppgång

data/samples/scheduled_actions.rising_sun

@@ -0,0 +1,4 @@
+tänd ovanvåning vid solnedgång
+släck ovanvåning klockan 22:15
+släck ovanvåning vid soluppgång
+tänd ovanvåning klockan 06:05