trigger_switch_d 0.1.0

data/lib/tellstick/tellstick_io.rb

@@ -0,0 +1,80 @@
+# 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/>.
+
+
+require "rubygems"
+require "ftd2xx"
+require "pp"
+
+module Tellstick
+  
+  #IO stream associated with the tellstick
+  class TellstickIO
+    def initialize
+      open
+    end
+
+    #writes input string to tellstick
+    def puts(input)
+      input.scan(/.{1,8}/).each do |str|
+        Ftd2xx.write(@handle,str)
+      end
+    end
+    
+    #reads string from tellstick
+    def gets
+      reply = ""
+      bytes_read = 1
+      c = " "
+      while (bytes_read != 0) and (c != "\n")
+        c = " "
+        bytes_read = Ftd2xx.read(@handle,c)
+        reply << c
+      end
+      reply
+    end
+    
+    #close tellstick stream
+    def close
+      Ftd2xx.ft_close(@handle)
+      @handle = nil
+    end
+    
+    #opens tellstick stream
+    def open
+      Ftd2xx.ft_set_vidpid(0x1781,0x0c30)
+      device_index = Ftd2xx.create_device_info_list - 1
+      @handle = Ftd2xx.open(device_index)
+      Ftd2xx.ft_set_baud_rate(@handle,4800)
+      Ftd2xx.ft_set_timeouts(@handle,5000,0)
+      if @handle == nil
+        def puts(input);end 
+        def gets;end 
+      end
+    end
+    
+    #true if connected
+    def connected?
+      close
+      open
+      puts("S+")
+      answer = gets
+      close
+      open
+      answer == "+S\r\n"
+    end
+  end
+end

data/lib/tellstick.rb

@@ -0,0 +1,20 @@
+# 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/>.
+
+
+require "tellstick/tellstick"
+require "tellstick/tellstick_io"
+

data/lib/trigger_switch_d/action.rb

@@ -0,0 +1,83 @@
+# 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/>.
+
+
+require File.join(File.dirname(__FILE__),"trigger_switch_d_helper")
+
+module TriggerSwitchD
+  #Uses the ruby engine to transform code_line into method execute on an instance of Action
+  class Action
+
+    #Takes a code_line to be scheduled or executed together with the devices, environment
+    #and date to validate it.
+    def initialize(code_line,devices,environment=Config.default_environment,date=Date.today)
+      @name = code_line.strip
+      @date = date
+      @at_location = environment[:at_location]
+      @lookup = environment[:lookup]
+      tokens = code_line.scan(/(\w+) (\w+) (\w+) ([\w\d:]+)/u).flatten
+      (class << self;self;end).methodize_device(tokens[1],devices[tokens[1]],@lookup) if devices.include? tokens[1]
+      code = tokens.map do |token|
+        (@lookup.include? token) ? @lookup[token] : token
+      end.reverse
+      @at, executable = send(code[3], send(code[2], send(code[1], code[0])))
+      (class << self;self;end).methodize_executable(executable)
+    end
+    
+    def activate(*args) #:nodoc:
+      action(args[0][0],args[0][1],:turn_on)
+    end
+    
+    def deactivate(*args) #:nodoc:
+      action(args[0][0],args[0][1],:turn_off)
+    end
+    
+    def at(*args) #:nodoc:
+      return @at if args[0] == nil
+      if (args[0] =~ /(?:2[0-3]|[01]\d):[0-5]\d/) == 0
+        return args[0]
+      end
+      return @date.extend(Daylight).send(args[0],@at_location).localtime.strftime("%H:%M")
+    end
+    
+    def to_s
+      @name
+    end
+    
+    private
+    
+    def action(*args)
+      switches, at_time, event = args
+      code = Proc.new do |output|
+        switches.each do |switch|
+          Tellstick::create(output,switch.model_name).send(event,switch.house_code, switch.unit_code)
+        end
+      end
+      [at_time,code]
+    end
+    
+    def self.methodize_executable(executable)
+      define_method(:execute,&executable)
+    end
+    
+    def self.methodize_device(name,switches,lookup)
+      lookup[name] = :remote_device.to_s
+      define_method(:remote_device) do |*args|
+        [switches,args[0]]
+      end
+    end
+  end
+end

data/lib/trigger_switch_d/application.rb

@@ -0,0 +1,89 @@
+# 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/>.
+
+require 'socket'
+require 'yaml'
+require 'logger'
+require 'ipc'
+
+
+module TriggerSwitchD
+
+  #starts an instance of the daemon.
+  class Application    
+    attr_reader :devices, :schedule, :logger
+    alias_method :list_devices, :devices
+    
+    #Prepares the run by loading up the environment
+    #located in config/config.rb
+    def initialize(config_file)
+      @current_date = Date.new
+      ConfigFactory.new(config_file)
+      @logger = Logger.new(Config.log_object)
+      logger.info("Environment prepared")
+    end
+    
+    #Runs the daemon untill process killed or it receives
+    #stop from client connected via unix socket
+    def start
+      com_thread = IPC.create(Config.unix_socket_path)
+      logger.info("IPC started")
+      com_thread["received"] = "anything"
+      while ((command = com_thread["received"].to_sym) != :stop)
+        now_time = Time.new
+        load_db(now_time.strftime("%Y-%m-%d %H:%M:%S"))
+        hhmm_now_time = now_time.strftime("%H:%M")
+        if methods.include? command.to_s
+          com_thread["response"] = send(command).to_yaml
+          logger.info("Received #{command} via IPC")
+          Config.log_object.flush
+          com_thread["received"] = "anything"
+          com_thread.run
+        end
+        if (schedule.cronological.keys.include? hhmm_now_time)
+          logger.info("Executed #{schedule.cronological[hhmm_now_time].length} action(s) at #{hhmm_now_time}")
+          Config.log_object.flush
+          schedule.execute(hhmm_now_time,Config.output)
+        end
+        Kernel.sleep(1)
+        com_thread["received"] = "anything" if com_thread["received"] == ""
+      end
+      logger.info("Received #{command} via IPC")
+    end
+    
+    def list_schedule #:nodoc:
+      schedule.by_name.keys
+    end
+
+    private
+    
+    def load_db(time)
+      date = Date.parse(time)
+      return unless @current_date < date
+      file = File.open(Config.db_path[0],"r")
+      @devices = TriggerSwitchD::load_devices(file)
+      file.close
+      @schedule = Schedule.create
+      file = File.open(Config.db_path[1],"r")
+      TriggerSwitchD::load_scheduled_actions(file,@schedule,devices,Config.environment)
+      file.close
+      logger.info("Loaded #{devices.length} devices and #{schedule.by_name.length} actions")
+      Config.log_object.flush
+      @current_date = date
+    end
+        
+  end
+end

data/lib/trigger_switch_d/config.rb

@@ -0,0 +1,83 @@
+# 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/>.
+
+
+module TriggerSwitchD
+  module ConfigFactory
+    
+    #Creates the Config class from the config/config.rb file
+    #See samples/config.rb for more documentation
+    def self.new(file=StringIO.new)
+      env = file.readlines
+      attributes = env.map do |attribute|
+        attribute.scan(/Config.([\w_]+) =/).flatten[0]
+      end
+      cls = <<-EOS
+      class Config
+         #{attributes.map {|name| "def self.#{name}=(value); #{append_filenames(name)}; end"}.join("\n")}
+         
+         #{attributes.map {|name| "def self.#{name}; @#{name}; end"}.join("\n")}
+         
+         def self.default_environment
+           {:lookup => {"tänd" => "activate", 
+                     "släck" => "deactivate", 
+                     "soluppgång" => "sunrise", 
+                     "solnedgång" => "sunset",
+                     "klockan" => "at",
+                     "vid" => "at"},
+           :at_location => {:north => 0.0, :west => 0.0}}
+         end
+      end
+      EOS
+      ::TriggerSwitchD.module_eval(cls)
+      setup_environment(env)
+    end
+    
+    private
+    def self.setup_environment(env)
+      env.map do |attribute|
+        ::TriggerSwitchD.module_eval(attribute)
+      end
+      def Config.environment
+        result = default_environment
+        file = File.open(Config.dsl_path,"r")
+        result[:lookup] = YAML::load(file)
+        file.close
+        result[:at_location] = Config.geo_position
+        result
+      end
+    end
+
+    def self.set_type(name)
+      types = {"log_object" => "{:spec => StringIO.new, :development => STDOUT, :file => File.open(\"#log_path}\",\"a+\")}",
+                "output" => "{:spec => StringIO.new, :development => STDOUT, :tellstick => Tellstick::TellstickIO.new}"}
+      return "@#{name}=value" unless types.keys.include? name
+      "@#{name}=#{types[name]}[value]".gsub("log_path","{log_path")
+    end
+
+    def self.append_filenames(name)
+      filenames = {"log_path" => ["tsd.log"], "db_path" => ["devices","scheduled_actions"],
+                   "dsl_path" => ["lookup.dsl"], "unix_socket_path" => ["com.adhocskill.trigger_switch_d"]}
+      return set_type(name) unless filenames.keys.include? name
+      result = filenames[name].map do |fname|
+        "#value}/#{fname}"
+      end.inspect.gsub("value","{value")
+      result = result.gsub("[","").gsub("]","") if filenames[name].length == 1
+      "@#{name}=#{result}"
+    end
+  end
+end
+

data/lib/trigger_switch_d/daylight.rb

@@ -0,0 +1,114 @@
+# 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/>.
+
+
+# External referenses used:
+# http://www.stjarnhimlen.se (accessed 2010-03-02)
+# 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
+
+  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}
+  
+  def self.extended(receiver)
+    days = receiver.jd
+    raise "method jd on #{receiver} does not return Fixnum" unless days.kind_of? Fixnum
+  end
+
+  def sunrise(at_location)
+    time_for(:sunrise,at_location)
+  end
+
+  def sunset(at_location)
+    time_for(:sunset,at_location)
+  end
+  
+  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
+
+  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 
+    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
+  end
+  
+  def per_unit_circle(value)
+    value / UNIT_CIRCLE
+  end
+  
+  def mod_unit_circle(value)
+    value % UNIT_CIRCLE
+  end
+
+  def __prepare_float__
+    Float.class_eval {include DayFloat}
+    def __prepare_float__
+    end
+  end
+  
+  module DayFloat
+    def to_rad
+      self * Math::PI/180.0
+    end
+    def to_degrees
+      self * 180.0/Math::PI
+    end
+  end
+  
+end

data/lib/trigger_switch_d/ipc.rb

@@ -0,0 +1,39 @@
+# 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/>.
+
+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
+      end
+    end
+  end
+end

data/lib/trigger_switch_d/schedule.rb

@@ -0,0 +1,95 @@
+# 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/>.
+
+
+require File.join(File.dirname(__FILE__),"trigger_switch_d_helper")
+require File.join(File.dirname(__FILE__),"action")
+
+module TriggerSwitchD
+  #Holds actions organized by name and cronological
+  #Use create to instasiate 
+  module Schedule  
+    module InstanceMethods
+      def schedule_action(action)
+        self._insert_action_(action) if find(action.to_s) == nil
+        find(action.to_s)
+      end
+      
+      #find by name
+      def find(name)
+        by_name[name]
+      end
+      
+      #Returns when the next action is scheduled to occur
+      #based on the hour_minute. The format is "HH:MM" for both
+      #hour_minute as well as the result, with the exception
+      #that if no next action is found it will return
+      #"23:59:59" 
+      def next_action_at(hour_minute)
+        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|
+          time < Time.parse(at)
+        end
+      end
+      
+      #deletes action from schedule, returning the action on exit
+      def delete(name)
+        action = by_name.delete(name)
+        cronological[action.at].delete(name)
+      end
+
+      #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)
+      end
+
+      #Hash of actions accessible by "HH:MM" format
+      def cronological
+        self[:cronological]
+      end
+      
+      #Hash of actions accessible by name
+      def by_name
+        self[:all]
+      end
+
+      def _remove_executed_actions_from_schedule_(at) #:nodoc:
+        cronological[at].values.clone.each do |element|
+          by_name.delete(element.to_s)
+        end unless cronological[at] == nil
+        cronological.delete(at)
+      end
+
+      def _insert_action_(action) #:nodoc:
+        name = action.to_s
+        by_name[name] = action
+        cronological[action.at] ||= {}
+        cronological[action.at][name] = by_name[name]
+      end
+    end
+    
+    #Creates an instance of a schedule
+    def create
+      schedule = {:all => {}, :cronological => {}}
+      schedule.extend InstanceMethods
+    end
+    
+    module_function :create
+  end  
+end

data/lib/trigger_switch_d/switch.rb

@@ -0,0 +1,37 @@
+# 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/>.
+
+
+module TriggerSwitchD
+  module SwitchFactory
+    #Creates the Switch class dynamically from values, which is
+    #assumed to be an Array of attributes/keys
+    def self.new(values)
+      definition = <<-EOS
+      class Switch
+        attr_reader #{values.map {|name| ":#{name}"}.join(",")}
+        def initialize(value)
+          value.each_pair do |key,value|
+            instance_variable_set("@"+key.to_s,value) if respond_to?(key)
+          end
+        end
+      end
+      EOS
+      ::TriggerSwitchD.module_eval(definition)
+      ::TriggerSwitchD.const_get("Switch")
+    end
+  end
+end

data/lib/trigger_switch_d/trigger_switch_d_helper.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/>.
+
+
+module TriggerSwitchD
+  
+  #Loads up schedule with the actions in file
+  def load_scheduled_actions(file,schedule,devices,environment,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
+    end
+  end
+  
+  #Returns devices loaded from file
+  def 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
+    end
+    result
+  end
+
+  module_function :load_scheduled_actions, :load_devices
+end