lightwaverf 0.3.3 → 0.4.0

data/bin/lightwaverf

@@ -9,12 +9,20 @@ case ARGV[0]
     puts LightWaveRF.new.configure
   when 'sequence'
     puts LightWaveRF.new.sequence ARGV[1], ARGV[2]
+  when 'mood'
+    puts LightWaveRF.new.mood ARGV[1], ARGV[2], ARGV[3]
+  when 'learnmood'
+    puts LightWaveRF.new.learnmood ARGV[1], ARGV[2], ARGV[3]
   when 'energy'
     puts LightWaveRF.new.energy ARGV[1], ARGV[2], ARGV[3]
+  when 'update_timers'
+    puts LightWaveRF.new.update_timers ARGV[1], ARGV[2], ARGV[3]
   when 'timer'
-    puts LightWaveRF.new.timer ARGV[1], ARGV[2]
+    puts LightWaveRF.new.run_timers ARGV[1], ARGV[2]
+  when 'run_timers'
+    puts LightWaveRF.new.run_timers ARGV[1], ARGV[2]
   when 'update'
-    puts LightWaveRF.new.update_config ARGV[1], ARGV[2], ARGV[3]
+    puts LightWaveRF.new.update_config ARGV[1], ARGV[2]
   else
     LightWaveRF.new.send ARGV[0], ARGV[1], ARGV[2], ARGV[3]
 end

data/lib/lightwaverf.rb

@@ -1,17 +1,43 @@
+# TODO:
+# All day events without times - need to fix regex
+# Make regex better
+# Get rid of references in yaml cache file - use dup more? Or does it not matter?
+# Cope with events that start and end in the same run?
+# Add info about states to timer log
+# Consider adding a 'random' time shift modifier to make holiday security lights more 'realistic'
+# Build / update cron job automatically
+
+
 require 'yaml'
 require 'socket'
+require 'net/http'
+require 'uri'
+require 'net/https'
+require 'json'
+require 'rexml/document'
+require 'time'
+require 'date'
 include Socket::Constants
 
 class LightWaveRF
 
   @config_file = nil
   @log_file = nil
+  @log_timer_file = nil
   @config = nil
+  @timers = nil
 
   # Display usage info
-  def usage
+  def usage room = nil
     rooms = self.class.get_rooms self.get_config
-    'usage: lightwaverf ' + rooms.values.first['name'] + ' ' + rooms.values.first['device'].keys.first.to_s + ' on # where "' + rooms.keys.first + '" is a room in ' + self.get_config_file
+    config = 'usage: lightwaverf ' + rooms.values.first['name'] + ' ' + rooms.values.first['device'].keys.first.to_s + ' on # where "' + rooms.keys.first + '" is a room in ' + self.get_config_file
+    if room and rooms[room]
+      config += "\ntry: lightwaverf " + rooms[room]['name'] + ' all on'
+      rooms[room]['device'].each do | device |
+        config += "\ntry: lightwaverf " + rooms[room]['name'] + ' ' + device.first.to_s + ' on'
+      end
+    end
+    config
   end
 
   # Display help
@@ -30,11 +56,11 @@ class LightWaveRF
   #   debug: (Boolean
   def configure debug = false
     config = self.get_config
-    puts 'What is the ip address of your wifi link? (' + self.get_config['host'] + '). Enter a blank line to broadcast UDP commands.'
-    host = STDIN.gets.chomp
-    if ! host.to_s.empty?
-      config['host'] = host
-    end
+    # puts 'What is the ip address of your wifi link? (' + self.get_config['host'] + '). Enter a blank line to broadcast UDP commands.'
+    # host = STDIN.gets.chomp
+    # if ! host.to_s.empty?
+    #   config['host'] = host
+    # end
     puts 'What is the address of your google calendar? (' + self.get_config['calendar'] + '). Optional!'
     calendar = STDIN.gets.chomp
     if ! calendar.to_s.empty?
@@ -47,9 +73,7 @@ class LightWaveRF
         parts = device.split ' '
         if !parts[0].to_s.empty? and !parts[1].to_s.empty?
           new_room = parts.shift
-          if ! config['room']
-            config['room'] = [ ]
-          end
+          config['room'] ||= [ ]
           found = false
           config['room'].each do | room |
             if room['name'] == new_room
@@ -59,7 +83,7 @@ class LightWaveRF
             debug and ( p 'so now room is ' + room.to_s )
           end
           if ! found
-            config['room'].push 'name' => new_room, 'device' => parts
+            config['room'].push 'name' => new_room, 'device' => parts, 'mood' => nil
           end
           debug and ( p 'added ' + parts.to_s + ' to ' + new_room )
         end
@@ -84,9 +108,64 @@ class LightWaveRF
     @log_file || File.expand_path('~') + '/lightwaverf.log'
   end
 
+  # Timer log file getter
+  def get_timer_log_file
+    @timer_log_file || File.expand_path('~') + '/lightwaverf-timer.log'
+  end
+
+  # Timer logger
+  def log_timer_event type, room = nil, device = nil, state = nil, result = false
+    # create log message
+    message = nil
+    case type
+    when 'update'
+      message = '### Updated timer cache'
+    when 'run'
+      message = '*** Ran timers'
+    when 'sequence'
+      message = 'Ran sequence: ' + state
+    when 'mood'
+      message = 'Set mood: ' + mood + ' in room ' + room
+    when 'device'
+      message = 'Set device: ' + device + ' in room ' + room + ' to state ' + state
+    end
+    unless message.nil?
+      File.open( self.get_timer_log_file, 'a' ) do | f |
+        f.write("\n" + Time.now.to_s + ' - ' + message + ' - ' + ( result ? 'SUCCESS!' : 'FAILED!' ))
+      end
+    end
+  end
+
+  # Timer cache file getter
+  def get_timer_cache_file
+    @log_file || File.expand_path('~') + '/lightwaverf-timer-cache.yml'
+  end
+
+  # Get timer cache file, create it if needed
+  def get_timer_cache
+    p 'getting timer cache...'
+    if ! @timers
+      p 'no timers!'
+      if ! File.exists? self.get_timer_cache_file
+        p 'no file!'
+	self.update_timers
+        p 'updated...'
+      end
+      @timers = YAML.load_file self.get_timer_cache_file
+      p 'timers now ' + @timers.to_s
+    end
+    p 'returning, timers now ' + @timers.to_s
+    @timers
+  end
+
+  # Store the timer cache
+  def put_timer_cache timers = { 'events' => [ ] }
+    File.open( self.get_timer_cache_file, 'w' ) do | handle |
+      handle.write YAML.dump( timers )
+    end
+  end
+
   def put_config config = { 'room' => [ { 'name' => 'our', 'device' => [ 'light', 'lights' ] } ] }
-    puts 'put_config got ' + config.to_s
-    puts 'so writing ' + YAML.dump( config )
     File.open( self.get_config_file, 'w' ) do | handle |
       handle.write YAML.dump( config )
     end
@@ -117,99 +196,122 @@ class LightWaveRF
   # Credits:
   #   wonko - http://lightwaverfcommunity.org.uk/forums/topic/querying-configuration-information-from-the-lightwaverf-website/
   def update_config email = nil, pin = nil, debug = false
-  
+
     # Login to LightWaveRF Host server
-    require 'net/http'
-    require 'uri'
     uri = URI.parse 'https://lightwaverfhost.co.uk/manager/index.php'
     http = Net::HTTP.new uri.host, uri.port
     if uri.scheme == 'https'
-        require 'net/https'
         http.use_ssl = true
     end
     data = 'pin=' + pin + '&email=' + email
-    headers = { 'Content-Type'=> 'application/x-www-form-urlencoded '}
+    headers = { 'Content-Type'=> 'application/x-www-form-urlencoded' }
     resp, data = http.post uri.request_uri, data, headers
-    
+
     if resp and resp.body
-      # Extract JavaScript variables from the page
-      #   var gDeviceNames = [""]
-      #   var gDeviceStatus = [""]
-      #   var gRoomNames = [""]
-      #   var gRoomStatus = [""]
-      # http://rubular.com/r/UH0H4b4afF
-      variables = Hash.new
-      resp.body.scan(/var (gDeviceNames|gDeviceStatus|gRoomNames|gRoomStatus)\s*=\s*([^;]*)/).each do |variable|
-          variables[variable[0]] = variable[1].scan(/"([^"]*)\"/)
-      end
-      debug and (p '[Info - LightWaveRF Gem] Javascript variables ' + variables.to_s)
-      
-      rooms = [ ]
-      # Rooms - gRoomNames is a collection of 8 values, or room names
-      variables['gRoomNames'].each_with_index do |(roomName), roomIndex|
-        # Room Status - gRoomStatus is a collection of 8 values indicating the status of the corresponding room in gRoomNames
-        #   A: Active
-        #   I: Inactive
-        if variables['gRoomStatus'] and variables['gRoomStatus'][roomIndex] and variables['gRoomStatus'][roomIndex][0] == 'A'
-          # Devices - gDeviceNames is a collection of 80 values, structured in blocks of ten values for each room:
-          #   Devices 1 - 6, Mood 1 - 3, All Off
-          roomDevices = Array.new
-          deviceNamesIndexStart = roomIndex*10
-          variables['gDeviceNames'][(deviceNamesIndexStart)..(deviceNamesIndexStart+5)].each_with_index do |(deviceName), deviceIndex|
-            # Device Status - gDeviceStatus is a collection of 80 values which indicate the status/type of the corresponding device in gDeviceNames
-            #   O: On/Off Switch
-            #   D: Dimmer
-            #   R: Radiator(s)
-            #   P: Open/Close
-            #   I: Inactive (i.e. not configured)
-            #   m: Mood (inactive)
-            #   M: Mood (active)
-            #   o: All Off
-            deviceStatusIndex = roomIndex*10+deviceIndex
-            if variables['gDeviceStatus'] and variables['gDeviceStatus'][deviceStatusIndex] and variables['gDeviceStatus'][deviceStatusIndex][0] != 'I'
-                roomDevices << deviceName
-            end
-          end
-          # Create a hash of the active room and active devices and add to rooms array
-          if roomName and roomDevices and roomDevices.any?
-            rooms << {'name'=>roomName,'device'=>roomDevices}
-          end
-        end
-      end
-      
+      rooms = self.get_rooms_from resp.body, debug
       # Update 'room' element in LightWaveRF Gem config file
       # config['room'] is an array of hashes containing the room name and device names
       # in the format { 'name' => 'Room Name', 'device' => ['Device 1', Device 2'] }
-      if rooms and rooms.any?
+      if rooms.any?
         config = self.get_config
         config['room'] = rooms
-        File.open( self.get_config_file, 'w' ) do | handle |
-          handle.write YAML.dump( config )
-        end
-        debug and (p '[Info - LightWaveRF Gem] Updated config with ' + rooms.size.to_s + ' room(s): ' + rooms.to_s)
+        self.put_config config
+        debug and ( p '[Info - LightWaveRF Gem] Updated config with ' + rooms.size.to_s + ' room(s): ' + rooms.to_s )
       else
-        debug and (p '[Info - LightWaveRF Gem] Unable to update config: No active rooms or devices found')
+        debug and ( p '[Info - LightWaveRF Gem] Unable to update config: No active rooms or devices found' )
       end
     else
-      debug and (p '[Info - LightWaveRF Gem] Unable to update config: No response from Host server')
+      debug and ( p '[Info - LightWaveRF Gem] Unable to update config: No response from Host server' )
     end
     self.get_config
   end
 
+  def get_rooms_from body = '', debug = nil
+    variables = self.get_variables_from body, debug
+    rooms = [ ]
+    # Rooms - gRoomNames is a collection of 8 values, or room names
+    debug and ( puts variables['gRoomStatus'].inspect )
+    variables['gRoomNames'].each_with_index do | roomName, roomIndex |
+      # Room Status - gRoomStatus is a collection of 8 values indicating the status of the corresponding room in gRoomNames
+      #   A: Active
+      #   I: Inactive
+      if variables['gRoomStatus'] and variables['gRoomStatus'][roomIndex] and variables['gRoomStatus'][roomIndex][0] == 'A'
+        debug and ( puts variables['gRoomStatus'][roomIndex].inspect )
+        # Devices - gDeviceNames is a collection of 80 values, structured in blocks of ten values for each room:
+        #   Devices 1 - 6, Mood 1 - 3, All Off
+        roomDevices = [ ]
+        deviceNamesIndexStart = roomIndex * 10
+        variables['gDeviceNames'][(deviceNamesIndexStart)..(deviceNamesIndexStart+5)].each_with_index do | deviceName, deviceIndex |
+          # Device Status - gDeviceStatus is a collection of 80 values which indicate the status/type of the corresponding device in gDeviceNames
+          #   O: On/Off Switch
+          #   D: Dimmer
+          #   R: Radiator(s)
+          #   P: Open/Close
+          #   I: Inactive (i.e. not configured)
+          #   m: Mood (inactive)
+          #   M: Mood (active)
+          #   o: All Off
+          deviceStatusIndex = roomIndex * 10 + deviceIndex
+          if variables['gDeviceStatus'] and variables['gDeviceStatus'][deviceStatusIndex] and variables['gDeviceStatus'][deviceStatusIndex][0] != 'I'
+            roomDevices << deviceName
+          end
+        end
+        # Create a hash of the active room and active devices and add to rooms array
+        if roomName and roomDevices and roomDevices.any?
+          rooms << { 'name' => roomName, 'device' => roomDevices }
+        end
+      end
+    end
+    rooms
+  end
+
+  # Get variables from the source of lightwaverfhost.co.uk
+  # Separated out so it can be tested
+  #
+  def get_variables_from body = '', debug = nil
+    # debug and ( p '[Info - LightWaveRF Gem] body was ' + body.to_s )
+    variables = { }
+    # Extract JavaScript variables from the page
+    #   var gDeviceNames = [""]
+    #   var gDeviceStatus = [""]
+    #   var gRoomNames = [""]
+    #   var gRoomStatus = [""]
+    # http://rubular.com/r/UH0H4b4afF
+    body.scan( /var (gDeviceNames|gDeviceStatus|gRoomNames|gRoomStatus)\s*=\s*([^;]*)/ ).each do | variable |
+      if variable[0]
+        variables[variable[0]] = variable[1].scan /"([^"]*)\"/
+      end
+    end
+    debug and ( p '[Info - LightWaveRF Gem] so variables are ' + variables.inspect )
+    variables
+  end
+
   # Get a cleaned up version of the rooms and devices from the config file
   def self.get_rooms config = { 'room' => [ ]}, debug = false
     rooms = { }
     r = 1
     config['room'].each do | room |
       debug and ( puts room['name'] + ' = R' + r.to_s )
-      rooms[room['name']] = { 'id' => 'R' + r.to_s, 'name' => room['name'], 'device' => { }}
+      rooms[room['name']] = { 'id' => 'R' + r.to_s, 'name' => room['name'], 'device' => { }, 'mood' => { }, 'learnmood' => { }}
       d = 1
-      room['device'].each do | device |
-        # @todo possibly need to complicate this to get a device name back in here
-        debug and ( puts ' - ' + device + ' = D' + d.to_s )
-        rooms[room['name']]['device'][device] = 'D' + d.to_s
-        d += 1
+      unless room['device'].nil?
+        room['device'].each do | device |
+          # @todo possibly need to complicate this to get a device name back in here
+          debug and ( puts ' - ' + device + ' = D' + d.to_s )
+          rooms[room['name']]['device'][device] = 'D' + d.to_s
+          d += 1
+        end
+      end
+      m = 1
+      unless room['mood'].nil?
+        room['mood'].each do | mood |
+          rooms[room['name']]['mood'][mood] = 'FmP' + m.to_s
+          rooms[room['name']]['learnmood'][mood] = 'FsP' + m.to_s
+          m += 1
+        end
       end
+      # add 'all off' special mood
+      rooms[room['name']]['mood']['alloff'] = 'Fa'
       r += 1
     end
     rooms
@@ -235,6 +337,15 @@ class LightWaveRF
         state = 'Fa'
       when 'on'
         state = 'F1'
+      # preset dim levels
+      when 'low'
+        state = 'FdP8'
+      when 'mid'
+        state = 'FdP16'
+      when 'high'
+        state = 'FdP24'
+      when 'full'
+        state = 'FdP32'
       when 1..100
         state = 'FdP' + ( state * 0.32 ).round.to_s
       else
@@ -261,7 +372,7 @@ class LightWaveRF
       '666,!' + room['id'] + room['device'][device] + state + '|Turn ' + room['name'] + ' ' + device + '|' + state + ' via @pauly'
     else
       '666,!' + room['id'] + state + '|Turn ' + room['name'] + '|' + state + ' via @pauly'
-    end      
+    end
   end
 
   # Set the Time Zone on the LightWaveRF WiFi Link
@@ -278,7 +389,7 @@ class LightWaveRF
     debug and ( puts '[Info - LightWaveRF] timezone: response is ' + data )
     return (data == "666,OK\r\n")
   end
-  
+
   # Turn one of your devices on or off or all devices in a room off
   #
   # Example:
@@ -290,18 +401,36 @@ class LightWaveRF
   #   device: (String)
   #   state: (String)
   def send room = nil, device = nil, state = 'on', debug = false
-    debug and ( puts 'config is ' + self.get_config.to_s )
+    success = false
+    debug and ( p 'Executing send on device: ' + device + ' in room: ' + room + ' with state: ' + state )
     rooms = self.class.get_rooms self.get_config, debug
-    state = 'alloff' if (device.empty? and state == 'off')
-    state = self.class.get_state state
-    if rooms[room] and state and (state == 'Fa' || (device and rooms[room]['device'][device]))
-      command = self.command rooms[room], device, state
-      debug and ( p 'command is ' + command )
-      data = self.raw command
-      debug and ( p 'response is ' + data )
+    state = 'alloff' if ( device.empty? and state == 'off' )
+
+    unless rooms[room] and state
+      STDERR.puts self.usage( room );
     else
-      STDERR.puts self.usage
+      # support for setting state for all devices in the room (recursive)
+      if device == 'all'
+        debug and ( p 'Processing all devices...' )
+        rooms[room]['device'].each do | device_name, code |
+          debug and ( p "Device is: " + device_name )
+          self.send room, device_name, state, debug
+          sleep 1
+        end
+        success = true
+      # process single device
+      elsif state == 'alloff' || (device and rooms[room]['device'][device])
+        state = self.class.get_state state
+        command = self.command rooms[room], device, state
+        debug and ( p 'command is ' + command )
+        data = self.raw command
+        debug and ( p 'response is ' + data )
+        success = true
+      else
+        STDERR.puts self.usage( room );
+      end
     end
+    success
   end
 
   # A sequence of events
@@ -314,11 +443,92 @@ class LightWaveRF
   #   name: (String)
   #   debug: (Boolean)
   def sequence name, debug = false
+    success = true
     if self.get_config['sequence'][name]
       self.get_config['sequence'][name].each do | task |
-        self.send task[0], task[1], task[2], debug
+        if task[0] == 'pause'
+          debug and ( p 'Pausing for ' + task[1].to_s + ' seconds...' )
+          sleep task[1].to_i
+          debug and ( p 'Resuming...' )
+        elsif task[0] == 'mood'
+          self.mood task[1], task[2], debug
+        else
+          self.send task[0], task[1], task[2].to_s, debug
+        end
+        sleep 1
+      end
+      success = true
+    end
+    success
+  end
+
+  # Set a mood in one of your rooms
+  #
+  # Example:
+  #   >> LightWaveRF.new.mood 'living', 'movie'
+  #
+  # Arguments:
+  #   room: (String)
+  #   mood: (String)
+  def mood room = nil, mood = nil, debug = false
+    success = false
+    debug and (p 'Executing mood: ' + mood + ' in room: ' + room)
+    #debug and ( puts 'config is ' + self.get_config.to_s )
+    rooms = self.class.get_rooms self.get_config
+    # support for setting a mood in all rooms (recursive)
+    if room == 'all'
+      debug and ( p "Processing all rooms..." )
+      rooms.each do | config, each_room |
+        room = each_room['name']
+        debug and ( p "Room is: " + room )
+        success = self.mood room, mood, debug
         sleep 1
       end
+      success = true
+    # process single mood
+    else
+      if rooms[room] and mood
+        if rooms[room]['mood'][mood]
+          command = self.command rooms[room], nil, rooms[room]['mood'][mood]
+          debug and ( p 'command is ' + command )
+          self.raw command
+          success = true
+        # support for special "moods" via device looping
+        elsif mood[0,3] == 'all'
+          state = mood[3..-1]
+          debug and (p 'Selected state is: ' + state)
+          rooms[room]['device'].each do | device |
+            p 'Processing device: ' + device[0]
+            self.send room, device[0], state, debug
+            sleep 1
+          end
+          success = true
+        end
+      else
+        STDERR.puts self.usage( room );
+      end
+    end
+    success
+  end
+
+  # Learn a mood in one of your rooms
+  #
+  # Example:
+  #   >> LightWaveRF.new.learnmood 'living', 'movie'
+  #
+  # Arguments:
+  #   room: (String)
+  #   mood: (String)
+  def learnmood room = nil, mood = nil, debug = false
+    debug and (p 'Learning mood: ' + mood)
+    #debug and ( puts 'config is ' + self.get_config.to_s )
+    rooms = self.class.get_rooms self.get_config
+    if rooms[room] and mood and rooms[room]['learnmood'][mood]
+      command = self.command rooms[room], nil, rooms[room]['learnmood'][mood]
+      debug and ( p 'command is ' + command )
+      self.raw command
+    else
+      STDERR.puts self.usage( room )
     end
   end
 
@@ -336,8 +546,7 @@ class LightWaveRF
         data['message']['annotation'] = { 'title' => title.to_s, 'text' => note.to_s }
       end
       debug and ( p data )
-      require 'json'
-      File.open( self.get_log_file, 'a' ) do |f|
+      File.open( self.get_log_file, 'a' ) do | f |
         f.write( data.to_json + "\n" )
       end
       data['message']
@@ -348,7 +557,7 @@ class LightWaveRF
     response = nil
     # Get host address or broadcast address
     host = self.get_config['host'] || '255.255.255.255'
-    # Create socket 
+    # Create socket
     listener = UDPSocket.new
     # Add broadcast socket options if necessary
     if (host == '255.255.255.255')
@@ -372,81 +581,370 @@ class LightWaveRF
     response
   end
 
-  # Use a google calendar as a timer?
-  # Needs a google calendar, with its url in your config file, with events like "lounge light on" etc
-  # 
-  # Run this as a cron job every 5 mins, ie
-  # */5 * * * * /usr/local/bin/lightwaverf timer 5 > /tmp/timer.out 2>&1
-  # 
-  # Example:
-  #   >> LightWaveRF.new.timer
-  #   >> LightWaveRF.new.state 10
-  #
-  # Sample calendar:
-  #   https://www.google.com/calendar/feeds/aar79qh62fej54nprq6334s7ck%40group.calendar.google.com/public/basic
-  #   https://www.google.com/calendar/embed?src=aar79qh62fej54nprq6334s7ck%40group.calendar.google.com&ctz=Europe/London 
-  #
-  # Arguments:
-  #   interval: (Integer)
-  #   debug: (Boolean)
-  # 
-  def timer interval = 5, debug = false
-    require 'net/http'
-    require 'rexml/document'
-    url = LightWaveRF.new.get_config['calendar'] + '?singleevents=true&start-min=' + Date.today.strftime( '%Y-%m-%d' ) + '&start-max=' + Date.today.next.strftime( '%Y-%m-%d' )
+  def update_timers past = 60, future = 1440, debug = false
+    p '----------------'
+    p "Updating timers..."
+
+    # determine the window to query
+    now = Time.new
+    query_start = now - self.class.to_seconds( past )
+    query_end = now + self.class.to_seconds( future )
+
+    url = LightWaveRF.new.get_config['calendar']
+    # url += '?ctz=' + Time.new.zone
+    url += '?ctz=UTC'
+    url += '&singleevents=true'
+    url += '&start-min=' + query_start.strftime( '%FT%T%:z' ).sub('+', '%2B')
+    url += '&start-max=' + query_end.strftime( '%FT%T%:z' ).sub('+', '%2B')
     debug and ( p url )
     parsed_url = URI.parse url
     http = Net::HTTP.new parsed_url.host, parsed_url.port
     begin
       http.use_ssl = true
     rescue
-      debug and ( p 'cannot use ssl' )
+      debug and ( p 'cannot use ssl, tried ' + parsed_url.host + ', ' + parsed_url.port.to_s )
+      url.gsub! 'https:', 'http:'
+      debug and ( p 'so fetching ' + url )
+      parsed_url = URI.parse url
+      http = Net::HTTP.new parsed_url.host
     end
     request = Net::HTTP::Get.new parsed_url.request_uri
     response = http.request request
-    doc = REXML::Document.new response.body
-    now = Time.now.strftime '%H:%M'
-    interval_end_time = ( Time.now + interval.to_i * 60 ).strftime '%H:%M'
-    triggered = []
-    doc.elements.each 'feed/entry' do | e |
-      command = /(\w+) (\w+)( (\w+))?/.match e.elements['title'].text # look for events with a title like 'lounge light on'
-      if command
-        room = command[1].to_s
-        device = command[2].to_s
-        status = command[4]
-        timer = /When: ([\w ]+) (\d\d:\d\d) to ([\w ]+)?(\d\d:\d\d)/.match e.elements['summary'].text
-        if timer
-          event_time = timer[2].to_s
-          event_end_time = timer[4]
-        else
-          STDERR.puts 'did not get When: in ' + e.elements['summary'].text
-        end
-        # @todo fix events that start and end in this period
-        if status
-          event_times = { event_time => status }
-        else
-          event_times = { event_time => 'on', event_end_time => 'off' }
+
+    # if we get a good response
+    debug and ( p "Response code is: " + response.code)
+    if response.code == '200'
+      debug and ( p "Retrieved calendar ok")
+      doc = REXML::Document.new response.body
+      now = Time.now.strftime '%H:%M'
+
+      events = [ ]
+      states = [ ]
+
+      # refresh the list of entries for the caching period
+      doc.elements.each 'feed/entry' do | e |
+        debug and ( p "-------------------")
+        debug and ( p "Processing entry...")
+        event = Hash.new
+
+        # tokenise the title
+        debug and ( p "Event title is: " + e.elements['title'].text )
+        command = e.elements['title'].text.split
+        command_length = command.length
+        debug and ( p "Number of words is: " + command_length.to_s )
+        if command and command.length >= 1
+          first_word = command[0].to_s
+          # determine the type of the entry
+          if first_word[0,1] == '#'
+            debug and ( p "Type is: state" )
+            event['type'] = 'state' # temporary type, will be overridden later
+            event['room'] = nil
+            event['device'] = nil
+            event['state'] = first_word[1..-1].to_s
+            modifier_start = command_length # can't have modifiers on states
+          else
+            case first_word
+            when 'mood'
+              debug and ( p "Type is: mood" )
+              event['type'] = 'mood'
+              event['room'] = command[1].to_s
+              event['device'] = nil
+              event['state'] = command[2].to_s
+              modifier_start = 3
+            when 'sequence'
+              debug and ( p "Type is: sequence" )
+              event['type'] = 'sequence'
+              event['room'] = nil
+              event['device'] = nil
+              event['state'] = command[1].to_s
+              modifier_start = 2
+            else
+              debug and ( p "Type is: device" )
+              event['type'] = 'device'
+              event['room'] = command[0].to_s
+              event['device'] = command[1].to_s
+              # handle optional state
+              if command_length > 2
+                third_word = command[2].to_s
+                first_char = third_word[0,1]
+                debug and ( p "First char is: " + first_char )
+                # if the third word does not start with a modifier flag, assume it's a state
+                if first_char != '@' and first_char != '!' and first_char != '+' and first_char != '-'
+                  debug and ( p "State has been given.")
+                  event['state'] = command[2].to_s
+                  modifier_start = 3
+                else
+                  debug and ( p "State has not been given." )
+                  modifier_start = 2
+                end
+              else
+                debug and ( p "State has not been given." )
+                event['state'] = nil
+                modifier_start = 2
+              end
+            end
+          end
+
+          # get modifiers if they exist
+          time_modifier = 0
+          if command_length > modifier_start
+            debug and ( p "May have modifiers..." )
+            when_modifiers = Array.new
+            unless_modifiers = Array.new
+            modifier_count = command_length - modifier_start
+            debug and ( p "Count of modifiers is " + modifier_count.to_s )
+            for i in modifier_start..(command_length-1)
+              modifier = command[i]
+              if modifier[0,1] == '@'
+                debug and ( p "Found when modifier: " + modifier[1..-1] )
+                when_modifiers.push modifier[1..-1]
+              elsif modifier[0,1] == '!'
+                debug and ( p "Found unless modifier: " + modifier[1..-1] )
+                unless_modifiers.push modifier[1..-1]
+              elsif modifier[0,1] == '+'
+                debug and ( p "Found positive time modifier: " + modifier[1..-1] )
+                time_modifier = modifier[1..-1].to_i
+              elsif modifier[0,1] == '-'
+                debug and ( p "Found negative time modifier: " + modifier[1..-1] )
+                time_modifier = modifier[1..-1].to_i * -1
+              end
+            end
+            # add when/unless modifiers to the event
+            event['when_modifiers'] = when_modifiers
+            event['unless_modifiers'] = unless_modifiers
+          end
+
+          # parse the date string
+          debug and ( p "Time string is: " + e.elements['summary'].text)
+          event_time = /When: ([\w ]+) (\d\d:\d\d) to ([\w ]+)?(\d\d:\d\d)&nbsp;\n(.*)<br>(.*)/.match e.elements['summary'].text
+          debug and ( p "Event times are: " + event_time.to_s )
+          start_date = event_time[1].to_s
+          start_time = event_time[2].to_s
+          end_date = event_time[3].to_s
+          end_time = event_time[4].to_s
+          timezone = event_time[5].to_s
+          if end_date == '' or end_date.nil? # copy start date to end date if it wasn't given (as the same date)
+            end_date = start_date
+          end
+          debug and ( p "Start date: " + start_date)
+          debug and ( p "Start time: " + start_time)
+          debug and ( p "End date: " + end_date)
+          debug and ( p "End time: " + end_time)
+          debug and ( p "Timezone: " + timezone)
+
+          # convert to datetimes
+          start_dt = DateTime.parse(start_date.strip + ' ' + start_time.strip + ' ' + timezone.strip)
+          end_dt = DateTime.parse(end_date.strip + ' ' + end_time.strip + ' ' + timezone.strip)
+
+          # apply time modifier if it exists
+          if time_modifier != 0
+            debug and ( p "Adjusting timings by: " + time_modifier.to_s)
+            start_dt = ((start_dt.to_time) + time_modifier*60).to_datetime
+            end_dt = ((end_dt.to_time) + time_modifier*60).to_datetime
+          end
+
+          debug and ( p "Start datetime: " + start_dt.to_s)
+          debug and ( p "End datetime: " + end_dt.to_s)
+
+          # populate the dates
+          event['date'] = start_dt
+          # handle device entries without explicit on/off state
+          if event['type'] == 'device' and ( event['state'].nil? or ( event['state'] != 'on' and event['state'] != 'off' ))
+            debug and ( p "Duplicating event without explicit on/off state...")
+            # if not state was given, assume we meant 'on'
+            if event['state'].nil?
+              event['state'] = 'on'
+            end
+            end_event = event.dup # duplicate event for start and end
+            end_event['date'] = end_dt
+            end_event['state'] = 'off'
+            events.push event
+            events.push end_event
+          # create state plus start and end events if a state
+          elsif event['type'] == 'state'
+            debug and ( p "Processing state : " + event['state'])
+            # create state
+            state = Hash.new
+            state['name'] = event['state']
+            state['start'] = start_dt.dup
+            state['end'] = end_dt.dup
+            states.push state
+            # convert event to start and end sequence
+            event['type'] = 'sequence'
+            event['state'] = state['name'] + '_start'
+            end_event = event.dup # duplicate event for start and end
+            end_event['date'] = end_dt
+            end_event['state'] = state['name'] + '_end'
+            events.push event
+            events.push end_event
+          # else just add the event
+          else
+            events.push event
+          end
+
         end
-        event_times.each do | t, s |
-          debug and ( p e.elements['title'].text + ' - ' + now + ' < ' + t + ' < ' + interval_end_time + ' ?' )
-          if t >= now and t < interval_end_time
-            debug and ( p 'so going to turn the ' + room + ' ' + device + ' ' + s.to_s + ' now!' )
-            self.send room, device, s.to_s
-            sleep 1
-            triggered << [ room, device, s ]
+
+      end
+
+      # record some timestamps
+      info = { }
+      info['updated_at'] = Time.new.strftime( '%FT%T%:z' )
+      info['start_time'] = query_start.strftime( '%FT%T%:z' )
+      info['end_time'] = query_end.strftime( '%FT%T%:z' )
+
+      # build final timer config
+      timers = { }
+      timers['info'] = info
+      timers['events'] = events
+      timers['states'] = states
+
+      p 'Timer list is: ' + YAML.dump( timers )
+
+      # store the list
+      put_timer_cache timers
+      self.log_timer_event 'update', nil, nil, nil, true
+
+    else
+        self.log_timer_event 'update', nil, nil, nil, false
+    end
+  end
+
+  # Convert a string to seconds, assume it is in minutes
+  def self.to_seconds interval = 0
+    match = /^(\d+)([shd])$/.match( interval.to_s )
+    if match
+      case match[2]
+      when 's'
+        return match[1].to_i
+      when 'h'
+        return match[1].to_i * 3600
+      when 'd'
+        return match[1].to_i * 86400
+      end
+    end
+    return interval.to_i * 60
+  end
+
+  def run_timers interval = 5, debug = false
+    p '----------------'
+    p "Running timers..."
+    get_timer_cache
+    debug and ( p 'Timer list is: ' + YAML.dump( @timers ))
+
+    # get the current time and end interval time
+    now = Time.new
+    start_tm = now - now.sec
+    end_tm = start_tm + self.class.to_seconds( interval )
+
+    # convert to datetimes
+    start_horizon = DateTime.parse start_tm.to_s
+    end_horizon = DateTime.parse end_tm.to_s
+    p '----------------'
+    p 'Start horizon is: ' + start_horizon.to_s
+    p 'End horizon is: ' + end_horizon.to_s
+
+    # sort the events and states (to guarantee order if longer intervals are used)
+    @timers['events'].sort! { | x, y | x['date'] <=> y['date'] }
+    @timers['states'].sort! { | x, y | x['date'] <=> y['date'] }
+
+    # array to hold events that should be executed this run
+    run_list = [ ]
+
+    # process each event
+    @timers['events'].each do | event |
+      debug and ( p '----------------' )
+      debug and ( p 'Processing event: ' + event.to_s )
+      debug and ( p 'Event time is: ' + event['date'].to_s )
+
+      # first, assume we'll not be running the event
+      run_now = false
+
+      # check that it is in the horizon time
+      unless event['date'] >= start_horizon and event['date'] < end_horizon
+        debug and ( p 'Event is NOT in horizon...ignoring')
+      else
+        debug and ( p 'Event is in horizon...')
+        run_now = true
+
+        # if has modifiers, check modifiers against states
+        unless event['when_modifiers'].nil?
+          debug and ( p 'Event has when modifiers. Checking they are all met...')
+
+          # determine which states apply at the time of the event
+          applicable_states = Array.new
+          @timers['states'].each do | state |
+            if event['date'] >= state['start'] and event['date'] < state['end']
+              applicable_states.push state['name']
+            end
           end
+          debug and ( p 'Applicable states are: ' + applicable_states.to_s)
+
+          # check that each when modifier exists in appliable states
+          event['when_modifiers'].each do | modifier |
+            unless applicable_states.include? modifier
+              debug and ( p 'Event when modifier not met: ' + modifier)
+              run_now = false
+              break
+            end
+          end
+
+          # check that each unless modifier does not exist in appliable states
+          event['unless_modifiers'].each do | modifier |
+            if applicable_states.include? modifier
+              debug and ( p 'Event unless modifier not met: ' + modifier)
+              run_now = false
+              break
+            end
+          end
+        end
+
+        # if we have determined the event should run, add to the run list
+        if run_now
+          run_list.push event
         end
       end
     end
-    triggered.length.to_s + " events triggered"
+
+    # process the run list
+    p '-----------------------'
+    p 'Events to execute this run are: ' + run_list.to_s
+
+    triggered = [ ]
+
+    run_list.each do | event |
+      # execute based on type
+      case event['type']
+      when 'mood'
+        p 'Executing mood. Room: ' + event['room'] + ', Mood: ' + event['state']
+        result = self.mood event['room'], event['state'], debug
+        sleep 1
+        triggered << [ event['room'], event['device'], event['state'] ]
+      when 'sequence'
+        p 'Executing sequence. Sequence: ' + event['state']
+        result = self.sequence event['state'], debug
+        sleep 1
+        triggered << [ event['room'], event['device'], event['state'] ]
+      else
+        p 'Executing device. Room: ' + event['room'] + ', Device: ' + event['device'] + ', State: ' + event['state']
+        result = self.send event['room'], event['device'], event['state'], debug
+        sleep 1
+        triggered << [ event['room'], event['device'], event['state'] ]
+      end
+        self.log_timer_event event['type'], event['room'], event['device'], event['state'], result
+    end
+
+    # update energy log
     title = nil
     text = nil
     if triggered.length > 0
       debug and ( p triggered.length.to_s + ' events so annotating energy log too...' )
       title = 'timer'
-      text = triggered.map { |e| e.join " " }.join ", "
+      text = triggered.map { | e | e.join " " }.join ", "
     end
     self.energy title, text, debug
+
+    self.log_timer_event 'run', nil, nil, nil, true
   end
+
 end
 

metadata

@@ -1,20 +1,53 @@
 --- !ruby/object:Gem::Specification
 name: lightwaverf
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
 - Paul Clarke
 - Ian Perrin
+- Julian McLean
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-17 00:00:00.000000000 Z
-dependencies: []
-description: Interact with lightwaverf wifi link from code or the command line. Control
-  your lights, heating, sockets etc. Also set up timers using a google calendar and
-  log energy usage.
+date: 2013-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    Interact with lightwaverf wifi-link from code or the command line.\n
+  \   Control your lights, heating, sockets etc.\n    Also set up timers using a google
+  calendar and log energy usage.\n"
 email: pauly@clarkeology.com
 executables:
 - lightwaverf
@@ -48,5 +81,5 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Home automation
+summary: Home automation with lightwaverf
 test_files: []