rzwaveway 0.0.11 → 0.0.13

data/lib/rzwaveway/events.rb

@@ -1,73 +1,25 @@
-module RZWaveWay
-  class AliveEvent
-    attr_reader :device_id
-    attr_reader :time
-
-    def initialize device_id, time
-      @device_id = device_id
-      @time = time
-    end
-  end
-
-  class NotAliveEvent
-    attr_reader :device_id
-    attr_reader :time_delay
-    attr_reader :missed_count
-
-    def initialize(device_id, time_delay, missed_count)
-      @device_id = device_id
-      @time_delay = time_delay
-      @missed_count = missed_count
-    end
-  end
-
-  class DeadEvent
-    attr_reader :device_id
-
-    def initialize(device_id)
-      @device_id = device_id
-    end
-  end
+require 'ostruct'
 
-  class LevelEvent
-    attr_reader :device_id
-    attr_reader :time
-    attr_reader :level
+module RZWaveWay
+  class Event < OpenStruct
+    def initialize(hash)
+      raise ArgumentError, 'Hash can not be nil' unless hash
+      raise ArgumentError, 'Missing device_id' unless hash.has_key? :device_id
+      hash[:time] = Time.now.to_i unless hash.has_key? :time
 
-    def initialize(device_id, time, level)
-      @device_id = device_id
-      @time = time
-      @level = level
+      super(hash)
     end
   end
 
-  class MultiLevelEvent < LevelEvent
-  end
-
-  class BatteryValueEvent
-    attr_reader :device_id
-    attr_reader :time
-    attr_reader :value
+  class AlarmEvent < Event ; end
 
-    def initialize(device_id, time, value)
-      @device_id = device_id
-      @time = time
-      @value = value
-    end
-  end
+  class AliveDevice < Event ; end
+  class InactiveDevice < Event ; end
+  class DeadDevice < Event ; end
 
-  class SmokeEvent
-    attr_reader :device_id
-    attr_reader :time
-  end
+  class LevelEvent < Event ; end
 
-  class HighTemperatureEvent
-    attr_reader :device_id
-    attr_reader :time
-  end
+  class MultiLevelEvent < LevelEvent ; end
 
-  class TamperingEvent
-    attr_reader :device_id
-    attr_reader :time
-  end
+  class BatteryValueEvent < Event ; end
 end

data/lib/rzwaveway/extensions/ssa_siren_strobe_alarm.rb

@@ -34,11 +34,6 @@ module RZWaveWay
         end
       end
 
-      def level!
-        @device.SwitchMultiLevel.get
-        nil
-      end
-
       private
 
       DISABLED = 0
@@ -46,7 +41,7 @@ module RZWaveWay
       SIREN = 66
 
       def set level
-        @device.SwitchMultiLevel.set level
+        @device.SwitchMultiLevel.level = level
       end
     end
   end

data/lib/rzwaveway/properties_cache.rb

@@ -0,0 +1,38 @@
+module RZWaveWay
+  module PropertiesCache
+    def save_properties
+      properties.values.each {|property| property.save}
+    end
+
+    def to_hash
+      properties.each_with_object({}) {|property, hash| hash[property[0]] = property[1].to_hash}
+    end
+
+    private
+
+    def define_property(property_name, key, read_only, data)
+      options = {
+        value: find("#{key}.value", data),
+        update_time: find("#{key}.updateTime", data),
+        read_only: read_only
+      }
+      property = Property.new(options)
+      properties[property_name] = property
+      (class << self; self end).send(:define_method, property_name) { property.value }
+    end
+
+    def find(name, data)
+      parts = name.split '.'
+      result = data
+      parts.each do | part |
+        raise "Could not find part '#{part}' in '#{name}'" unless result.has_key? part
+        result = result[part]
+      end
+      result
+    end
+
+    def properties
+      @properties ||= {}
+    end
+  end
+end

data/lib/rzwaveway/property.rb

@@ -0,0 +1,47 @@
+module RZWaveWay
+  class Property
+    attr_reader :value
+    attr_reader :update_time
+
+    def initialize(options)
+      @previous_value = @value = options[:value]
+      @previous_update_time = @update_time = options[:update_time]
+      @read_only = options[:read_only]
+    end
+
+    def changed?
+      @previous_value != @value
+    end
+
+    def read_only?
+      @read_only == true
+    end
+
+    def save
+      @previous_value = @value
+      @previous_update_time = @update_time
+    end
+
+    def to_hash
+      {
+        read_only: read_only?,
+        value: @value,
+        update_time: @update_time
+      }
+    end
+
+    def update(value, update_time)
+      if @update_time <= update_time
+        @update_time = update_time
+        if @value != value
+          @value = value
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/rzwaveway/version.rb

@@ -1,3 +1,3 @@
 module RZWaveWay
-  VERSION = '0.0.11'
+  VERSION = '0.0.13'
 end

data/lib/rzwaveway/zwave_device.rb

@@ -1,133 +1,120 @@
-require 'json'
-
 module RZWaveWay
   class ZWaveDevice
-    include CommandClass
     include CommandClasses
     include Logger
+    include PropertiesCache
 
-    attr_reader :name
     attr_reader :id
     attr_reader :last_contact_time
-    attr_accessor :contact_frequency
+    attr_reader :status
 
     def initialize(id, data)
       @id = id
+      @command_classes = {}
       initialize_from data
-      log.info "Created ZWaveDevice with name='#{name}' (id='#{id}')"
+      update_status
+      log.info "Created device with name='#{name}' status=#{status} (id='#{id}')"
+    end
+
+    def contact
+      RZWaveWay::ZWay.instance.run_zway_no_operation(id)
     end
 
     def contacts_controller_periodically?
       support_commandclass? CommandClass::WAKEUP
     end
 
-    def next_contact_time
-      @last_contact_time + (@contact_frequency * (1 + @missed_contact_count) * 1.1)
+    def inspect
+      output = [to_s]
+      output += @command_classes.collect {|id, command_class| "#{id} - #{command_class}"}
+      output.join "\n"
     end
 
     def support_commandclass?(command_class_id)
       @command_classes.has_key? command_class_id
     end
 
-    def process updates
-      events = []
+    def process(updates)
       updates_per_commandclass = group_per_commandclass updates
       updates_per_commandclass.each do |cc, values|
         if @command_classes.has_key? cc
-          event = @command_classes[cc].process(values)
-          events << event if event
+          @command_classes[cc].process(values) {|event| yield event}
         else
           log.warn "Could not find command class: '#{cc}'"
         end
       end
-      process_device_data(updates, events)
-      events
-    end
-
-    def process_alive_check
-      return if @dead
-      if @contact_frequency > 0
-        current_time = Time.now.to_i
-        delta = current_time - next_contact_time
-        if delta > 0
-          count = ((current_time - @last_contact_time) / @contact_frequency).to_i
-          if count > MAXIMUM_MISSED_CONTACT
-            @dead = true
-            DeadEvent.new(@id)
-          elsif count > @missed_contact_count
-            @missed_contact_count = count
-            NotAliveEvent.new(@id, delta, count)
-          end
-        end
-      end
+      process_device_data(updates)
+      save_changes
     end
 
     def notify_contacted(time)
-      if time.to_i > @last_contact_time
-        @dead = false
-        @last_contact_time = time.to_i
-        @missed_contact_count = 0
-        true
+      if time > @last_contact_time
+        @last_contact_time = time
       end
     end
 
-    def add_property(property)
-      name = property.delete(:name)
-      property[:read_only] = true unless property.has_key? :read_only
-      @properties[name] = property
+    def refresh
+      @command_classes.values.each do |command_class|
+        command_class.refresh if command_class.respond_to? :refresh
+      end
     end
 
-    def get_property(name)
-      [
-        @properties[name][:value],
-        @properties[name][:update_time]
-      ]
+    def state
+      hash = to_hash
+      @command_classes.values.each_with_object(hash) {|cc, hash| hash.merge!(cc.to_hash)}
     end
 
-    def properties
-      @properties.reject { |_, property| property.has_key? :internal }
+    def to_s
+      "#{id} (#{name}) - #{status} (#{Time.at(last_contact_time)})"
     end
 
-    def update_property(name, value, update_time)
-      if @properties.has_key?(name)
-        property = @properties[name]
-        if property[:value] != value || property[:update_time] < update_time
-          property[:value] = value
-          property[:update_time] = update_time
-          true
+    def update_status
+      @status = if contacts_controller_periodically?
+        if self.WakeUp.on_time?
+          :alive
+        elsif self.WakeUp.missed_contact_count < 10 # times
+          :inactive
+        else
+          :dead
+        end
+      else
+        if elapsed_minutes_since_last_contact > 60 # minutes
+          :dead
+        elsif elapsed_minutes_since_last_contact > 5  # minutes
+          :inactive
+        else
+          :alive
         end
       end
     end
 
     private
 
-    MAXIMUM_MISSED_CONTACT = 10
-
     def create_commandclasses_from data
-      cc_classes = {}
       data['instances']['0']['commandClasses'].each do |id, sub_tree|
         cc_id = id.to_i
-        cc_class = CommandClasses::Factory.instance.instantiate(cc_id, sub_tree, self)
-        cc_classes[cc_id] = cc_class
+        cc_class = CommandClasses::Factory.instance.instantiate(cc_id, self)
+        cc_class.build_from(sub_tree)
+        @command_classes[cc_id] = cc_class
         cc_class_name = cc_class.class.name.split('::').last
-        (class << self; self end).send(:define_method, cc_class_name) { cc_class } unless cc_class_name == 'Dummy'
+        (class << self; self end).send(:define_method, cc_class_name) { cc_class } unless cc_class_name == 'Unsupported'
       end
-      cc_classes
     end
 
-    def initialize_from data
-      @name = find('data.givenName.value', data)
-      last_contact_times = [
-        find('data.lastReceived.updateTime', data),
-        find('data.lastSend.updateTime', data)
-      ]
-      @last_contact_time = last_contact_times.max
+    def elapsed_minutes_since_last_contact(time = Time.now)
+      (time.to_i - last_contact_time) / 60
+    end
 
-      @dead = false
-      @missed_contact_count = 0
-      @contact_frequency = 0
-      @properties = {}
-      @command_classes = create_commandclasses_from data
+    def initialize_from data
+      define_property(:name, 'data.givenName', true, data)
+      define_property(:is_failed, 'data.isFailed', true, data)
+      define_property(:failure_count, 'data.failureCount', true, data)
+      
+      @last_contact_time = find('data.lastReceived.updateTime', data)
+      notify_contacted(properties[:is_failed].update_time) unless is_failed
+
+      create_commandclasses_from data
+      save_changes
     end
 
     def group_per_commandclass updates
@@ -137,7 +124,7 @@ module RZWaveWay
         match_data = key.match(/\Ainstances.0.commandClasses.(\d+)./)
         if match_data
           command_class = match_data[1].to_i
-          updates_per_commandclass[command_class] = {} unless updates_per_commandclass.has_key?(command_class)
+          updates_per_commandclass[command_class] ||= {}
           updates_per_commandclass[command_class][match_data.post_match] = value
         else
           other_updates[key] = value
@@ -148,15 +135,23 @@ module RZWaveWay
       updates_per_commandclass
     end
 
-    def process_device_data(updates, events)
-      times = []
-      updates.each do | key, value |
-        if key == 'data.lastReceived' || key == 'data.lastSend'
-          times << value['updateTime']
+    def process_device_data(data)
+      data.each do | key, value |
+        case key
+        when /^(?:data.)?failureCount/
+          properties[:failure_count].update(value['value'], value['updateTime'])
+        when /^(?:data.)?isFailed/
+          properties[:is_failed].update(value['value'], value['updateTime'])
+          notify_contacted(value['updateTime']) unless is_failed
+        when /^(?:data.)?lastReceived/
+          notify_contacted(value['updateTime'])
         end
       end
-      time = times.max
-      events << AliveEvent.new(@id, time) if notify_contacted(time)
+    end
+
+    def save_changes
+      save_properties
+      @command_classes.values.each {|cc| cc.save_properties}
     end
   end
 end

data/lib/rzwaveway/zway.rb

@@ -13,7 +13,10 @@ module RZWaveWay
     attr_reader :log
 
     def initialize
+      @devices = {}
+      @event_handlers = {}
       @log = default_logger
+      @update_time = '0'
     end
 
     def execute(device_id, command_class, command_class_function, argument = nil)
@@ -30,19 +33,31 @@ module RZWaveWay
       clazz.new(device)
     end
 
+    def inspect
+      content = to_s
+      devices.values.each {|device| content << "\n#{device}"}
+      content
+    end
+
+    def run_zway_no_operation device_id
+      run_zway "devices[#{device_id}].SendNoOperation()"
+    end
+
     def setup(options, *adapter_params)
       hostname = options[:hostname] || '127.0.0.1'
       port = options[:port] || 8083
+      username = options[:username] || 'admin'
+      password = options[:password] || 'changeme'
       adapter_params = :httpclient if adapter_params.compact.empty?
       @base_uri="http://#{hostname}:#{port}"
-      @connection = Faraday.new {|faraday| faraday.adapter *adapter_params}
+      @connection = Faraday.new do |connection|
+        connection.basic_auth username, password
+        connection.adapter *adapter_params
+      end
       @log = options[:logger] if options.has_key? :logger
     end
 
     def start
-      @devices = {}
-      @event_handlers = {}
-      @update_time = '0'
       loop do
         results = get_zway_data_tree_updates
         if results.has_key?('devices')
@@ -59,43 +74,52 @@ module RZWaveWay
       @event_handlers[event] = listener
     end
 
-    def process_events
-      check_devices
+    def process
       updates = get_zway_data_tree_updates
-      events = devices_process updates
-      check_not_alive_devices(events)
-      deliver_to_handlers(events)
-    end
-
-    private
+      updates_per_device = group_per_device updates
 
-    DATA_TREE_BASE_PATH='/ZWaveAPI/Data/'
-    RUN_BASE_PATH='/ZWaveAPI/Run/'
+      events = []
+      devices.each do |device_id, device|
+        previous_status = device.status
 
-    def check_devices
-      @devices.values.each do |device|
-        unless device.contacts_controller_periodically?
-          current_time = Time.now.to_i
-          # TODO ensure last_contact_time is set in the device initializer
-          if (current_time % 10 == 0) && (current_time > device.next_contact_time - 60)
-            run_zway_no_operation device.id
+        if updates_per_device.has_key? device_id
+          device_updates = updates_per_device[device_id]
+          device.process(device_updates) do |event|
+            events << event
           end
         end
+
+        if previous_status != device.update_status
+          events << create_status_event_for(device)
+        end
       end
+      deliver_to_handlers(events)
     end
 
-    def check_not_alive_devices(events)
-      @devices.values.each do |device|
-        event = device.process_alive_check
-        events << event if event
-      end
+    def to_s
+      "ZWay at '#{@base_uri}' with #{devices.count} device(s)"
     end
 
+    private
+
+    DATA_TREE_BASE_PATH='/ZWaveAPI/Data/'
+    RUN_BASE_PATH='/ZWaveAPI/Run/'
+
     def create_device(device_id, device_data_tree)
       if device_id > 1
-        device = ZWaveDevice.new(device_id, device_data_tree)
-        device.contact_frequency = 300 unless device.contacts_controller_periodically?
-        @devices[device_id] = device
+        @devices[device_id] = ZWaveDevice.new(device_id, device_data_tree)
+      end
+    end
+
+    def create_status_event_for(device)
+      log.debug "Device '#{device.name}' is now #{device.status}"
+      case device.status
+      when :alive
+        AliveDevice.new(device_id: device.id, time: device.last_contact_time)
+      when :inactive
+        InactiveDevice.new(device_id: device.id)
+      when :dead
+        DeadDevice.new(device_id: device.id)
       end
     end
 
@@ -114,20 +138,6 @@ module RZWaveWay
       end
     end
 
-    def devices_process updates
-      events = []
-      updates_per_device = group_per_device updates
-      updates_per_device.each do | id, updates |
-        if @devices[id]
-          device_events = @devices[id].process updates
-          events += device_events unless device_events.empty?
-        else
-          log.warn "Could not find device with id '#{id}'"
-        end
-      end
-      events
-    end
-
     def group_per_device updates
       updates_per_device = {}
       updates.each do | key, value |
@@ -152,7 +162,7 @@ module RZWaveWay
           results = JSON.parse response.body
           @update_time = results.delete('updateTime')
         else
-          log.error(response.reason)
+          log.error("#{response.status} - #{response.reason_phrase}" )
         end
       rescue StandardError => e
         log.error("Failed to communicate with ZWay HTTP server: #{e}")
@@ -190,10 +200,6 @@ module RZWaveWay
       run_zway command_path
     end
 
-    def run_zway_no_operation device_id
-      run_zway "devices[#{device_id}].SendNoOperation()"
-    end
-
     def run_zway command_path
       begin
         uri = URI.encode(@base_uri + RUN_BASE_PATH + command_path, '[]')