somfy_sdn 1.0.12 → 2.0.0

data/lib/sdn/message.rb

@@ -1,15 +1,21 @@
-require 'sdn/messages/helpers'
+require 'sdn/message/helpers'
 
 module SDN
   class MalformedMessage < RuntimeError; end
 
   class Message
     class << self
-      def expected_response
+      def inherited(klass)
+        return Message.inherited(klass) unless self == Message
+        @message_map = nil
+        (@subclasses ||= []) << klass
+      end
+
+      def expected_response?(message)
         if name =~ /::Get([A-Za-z]+)/
-          const_get("Post#{$1}", true)
+          message.class.name == name.sub("::Get", "::Post")
         else
-          Ack
+          message.is_a?(Ack) || message.is_a?(Nack)
         end
       end
 
@@ -19,20 +25,22 @@ module SDN
         # we loop here scanning for a valid message
         loop do
           offset += 1
+          # give these weird messages a chance
+          result = ILT2::MasterControl.parse(data)
+          return result if result
+
           return [nil, 0] if data.length - offset < 11
           msg = to_number(data[offset])
           length = to_number(data[offset + 1])
           ack_requested = length & 0x80 == 0x80
           length &= 0x7f
           # impossible message
-          next if length < 11 || length > 32
+          next if length < 11 || length > 43
           # don't have enough data for what this message wants;
           # it could be garbage on the line so keep scanning
           next if length > data.length - offset
 
-          message_class = constants.find { |c| (const_get(c, false).const_get(:MSG, false) rescue nil) == msg }
-          message_class = const_get(message_class, false) if message_class
-          message_class ||= UnknownMessage
+          message_class = message_map[msg] || UnknownMessage
 
           calculated_sum = checksum(data.slice(offset, length - 2))
           read_sum = data.slice(offset + length - 2, 2)
@@ -41,34 +49,41 @@ module SDN
           break
         end
 
-        puts "discarding invalid data prior to message #{data[0...offset].map { |b| '%02x' % b }.join(' ')}" unless offset == 0
-        puts "read #{data.slice(offset, length).map { |b| '%02x' % b }.join(' ')}"
-
-        reserved = to_number(data[offset + 2])
+        node_type = node_type_from_number(to_number(data[offset + 2]))
         src = transform_param(data.slice(offset + 3, 3))
         dest = transform_param(data.slice(offset + 6, 3))
         begin
-          result = message_class.new(reserved: reserved, ack_requested: ack_requested, src: src, dest: dest)
+          result = message_class.new(node_type: node_type, ack_requested: ack_requested, src: src, dest: dest)
           result.parse(data.slice(offset + 9, length - 11))
           result.msg = msg if message_class == UnknownMessage
         rescue ArgumentError => e
-          puts "discarding illegal message #{e}"
+          SDN.logger.warn "discarding illegal message of type #{message_class.name}: #{e}"
           result = nil
         end
         [result, offset + length]
       end
+
+      private
+
+      def message_map
+        @message_map ||=
+          @subclasses.inject({}) do |memo, klass|
+            next memo unless klass.constants(false).include?(:MSG)
+            memo[klass.const_get(:MSG, false)] = klass
+            memo
+          end
+      end
     end
 
     include Helpers
     singleton_class.include Helpers
 
-    attr_reader :reserved, :ack_requested, :src, :dest
-    attr_writer :ack_requested
+    attr_accessor :node_type, :ack_requested, :src, :dest
 
-    def initialize(reserved: nil, ack_requested: false, src: nil, dest: nil)
-      @reserved = reserved || 0x02 # message sent to Sonesse 30
+    def initialize(node_type: nil, ack_requested: false, src: nil, dest: nil)
+      @node_type = node_type || 0
       @ack_requested = ack_requested
-      if src.nil? && is_group_address?(dest)
+      if src.nil? && !dest.nil? && is_group_address?(dest)
         src = dest
         dest = nil
       end
@@ -81,7 +96,7 @@ module SDN
     end
 
     def serialize
-      result = transform_param(reserved) + transform_param(src) + transform_param(dest) + params
+      result = transform_param(node_type_to_number(node_type)) + transform_param(src) + transform_param(dest) + params
       length = result.length + 4
       length |= 0x80 if ack_requested
       result = transform_param(self.class.const_get(:MSG)) + transform_param(length) + result
@@ -94,11 +109,11 @@ module SDN
     end
 
     def inspect
-      "#<%s @reserved=%02xh, @ack_requested=%s, @src=%s, @dest=%s%s>" % [self.class.name, reserved, ack_requested, print_address(src), print_address(dest), class_inspect]
+      "#<%s @node_type=%s, @ack_requested=%s, @src=%s, @dest=%s%s>" % [self.class.name, node_type_to_string(node_type), ack_requested, print_address(src), print_address(dest), class_inspect]
     end
 
     def class_inspect
-      ivars = instance_variables - [:@reserved, :@ack_requested, :@src, :@dest]
+      ivars = instance_variables - [:@node_type, :@ack_requested, :@src, :@dest, :@params]
       return if ivars.empty?
       ivars.map { |iv| ", #{iv}=#{instance_variable_get(iv).inspect}" }.join
     end
@@ -121,19 +136,36 @@ module SDN
     class Nack < Message
       MSG = 0x6f
       PARAMS_LENGTH = 1
-      VALUES = { data_error: 0x01, unknown_message: 0x10, node_is_locked: 0x20, wrong_position: 0x21, limits_not_set: 0x22, ip_not_set: 0x23, out_of_range: 0x24, busy: 0xff }
+      VALUES = { data_error: 0x01,
+                 unknown_message: 0x10,
+                 node_is_locked: 0x20,
+                 wrong_position: 0x21,
+                 limits_not_set: 0x22,
+                 ip_not_set: 0x23,
+                 out_of_range: 0x24,
+                 busy: 0xff }
+                 # 17 limits not set?
+                 # 37 not implemented? (get motor rolling speed)
+                 # 39 at limit? blocked?
+
 
       # presumed
       attr_accessor :error_code
 
+      def initialize(dest = nil, error_code = nil, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.error_code = error_code
+      end
+
       def parse(params)
         super
         error_code = to_number(params[0])
-        self.error_code = VALUES[error_code] || error_code
+        self.error_code = VALUES.invert[error_code] || error_code
       end
     end
 
-    class Ack < Message
+    class Ack < SimpleRequest
       MSG = 0x7f
       PARAMS_LENGTH = 0
     end
@@ -142,10 +174,25 @@ module SDN
     class UnknownMessage < Message
       attr_accessor :msg, :params
 
+      def initialize(params = [], **kwargs)
+        super(**kwargs)
+        self.params = params
+      end
+
       alias parse params=
 
+      def serialize
+        # prevent serializing something we don't know
+        raise NotImplementedError unless params
+        super
+      end
+
       def class_inspect
-        result = ", @msg=%02xh" % msg
+        result = if self.class == UnknownMessage
+          result = ", @msg=%02xh" % msg 
+        else
+          super || ""
+        end
         return result if params.empty?
 
         result << ", @params=#{params.map { |b| "%02x" % b }.join(' ')}"
@@ -154,7 +201,11 @@ module SDN
   end
 end
 
-require 'sdn/messages/control'
-require 'sdn/messages/get'
-require 'sdn/messages/post'
-require 'sdn/messages/set'
+require 'sdn/message/control'
+require 'sdn/message/get'
+require 'sdn/message/post'
+require 'sdn/message/set'
+require 'sdn/message/ilt2/get'
+require 'sdn/message/ilt2/master_control'
+require 'sdn/message/ilt2/post'
+require 'sdn/message/ilt2/set'

data/lib/sdn/{messages → message}/control.rb

@@ -1,5 +1,46 @@
 module SDN
   class Message
+    class Lock < Message
+      MSG = 0x06
+      PARAMS_LENGTH = 5
+      TARGET_TYPE = { current: 0, up_limit: 1, down_limit: 2, ip: 4, unlock: 5, position_percent: 7 }
+
+      attr_reader :target_type, :target, :priority
+
+      def initialize(dest = nil, target_type = :unlock, target = nil, priority = 1, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.target_type = target_type
+        self.target = target
+        self.priority = priority
+      end
+
+      def target_type=(value)
+        raise ArgumentError, "target_type must be one of :current, :up_limit, :down_limit, :ip, :unlock, or :position_percent" unless TARGET_TYPE.keys.include?(value)
+        @target_type = value
+      end
+
+      def target=(value)
+        @target = value&. & 0xffff
+      end
+
+      def priority=(value)
+        @priority = value & 0xff
+      end
+
+      def parse(params)
+        super
+        self.target_type = TARGET_TYPE.invert[to_number(params[0])]
+        target = to_number(params[1..2], nillable: true)
+        self.target = target
+        self.priority = to_number(params[3])
+      end
+
+      def params
+        transform_param(TARGET_TYPE[target_type]) + from_number(target, 2) + transform_param(priority) + transform_param(0)
+      end
+    end
+
     # Move in momentary mode
     class Move < Message
       MSG = 0x01
@@ -32,7 +73,7 @@ module SDN
      end
 
      def duration=(value)
-        raise ArgumentError, "duration must be in range 0x0a to 0xff (#{value})" unless value && value >= 0x0a && value <= 0xff
+        raise ArgumentError, "duration must be in range 0x0a to 0xff (#{value})" if value && (value < 0x0a || value > 0xff)
         @duration = value
      end
 
@@ -48,18 +89,43 @@ module SDN
       end
     end
 
-    # Stop movement
-    class Stop < Message
-      MSG = 0x02
-      PARAMS_LENGTH = 1
+    # Move relative to current position
+    class MoveOf < Message
+      MSG = 0x04
+      PARAMS_LENGTH = 4
+      TARGET_TYPE = { next_ip: 0x00, previous_ip: 0x01, jog_down_pulses: 0x02, jog_up_pulses: 0x03, jog_down_ms: 0x04, jog_up_ms: 0x05 }
 
-      def initialize(dest = nil, **kwargs)
+      attr_reader :target_type, :target
+
+      def initialize(dest = nil, target_type = nil, target = nil, **kwargs)
         kwargs[:dest] ||= dest
         super(**kwargs)
+        self.target_type = target_type
+        self.target = target
+      end
+
+      def parse(params)
+        super
+        self.target_type = TARGET_TYPE.invert[to_number(params[0])]
+        target = to_number(params[1..2], nillable: true)
+        target *= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
+        self.target = target
+      end
+
+      def target_type=(value)
+        raise ArgumentError, "target_type must be one of :next_ip, :previous_ip, :jog_down_pulses, :jog_up_pulses, :jog_down_ms, :jog_up_ms" unless value.nil? || TARGET_TYPE.keys.include?(value)
+        @target_type = value
+      end
+
+      def target=(value)
+        value &= 0xffff if value
+        @target = value
       end
 
       def params
-        transform_param(0)
+        param = target || 0xffff
+        param /= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
+        transform_param(TARGET_TYPE[target_type]) + from_number(param, 2) + transform_param(0)
       end
     end
 
@@ -107,43 +173,18 @@ module SDN
       end
     end
 
-    # Move relative to current position
-    class MoveOf < Message
-      MSG = 0x04
-      PARAMS_LENGTH = 4
-      TARGET_TYPE = { next_ip: 0x00, previous_ip: 0x01, jog_down_pulses: 0x02, jog_up_pulses: 0x03, jog_down_ms: 0x04, jog_up_ms: 0x05 }
-
-      attr_reader :target_type, :target
+    # Stop movement
+    class Stop < Message
+      MSG = 0x02
+      PARAMS_LENGTH = 1
 
-      def initialize(dest = nil, target_type = nil, target = nil, **kwargs)
+      def initialize(dest = nil, **kwargs)
         kwargs[:dest] ||= dest
         super(**kwargs)
-        self.target_type = target_type
-        self.target = target
-      end
-
-      def parse(params)
-        super
-        self.target_type = TARGET_TYPE.invert[to_number(params[0])]
-        target = to_number(params[1..2], nillable: true)
-        target *= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
-        self.target = target
-      end
-
-      def target_type=(value)
-        raise ArgumentError, "target_type must be one of :next_ip, :previous_ip, :jog_down_pulses, :jog_up_pulses, :jog_down_ms, :jog_up_ms" unless value.nil? || TARGET_TYPE.keys.include?(value)
-        @target_type = value
-      end
-
-      def target=(value)
-        value &= 0xffff if value
-        @target = value
       end
 
       def params
-        param = target || 0xffff
-        param /= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
-        transform_param(TARGET_TYPE[target_type]) + from_number(param, 2) + transform_param(0)
+        transform_param(0)
       end
     end
 

data/lib/sdn/{messages → message}/get.rb

@@ -1,32 +1,43 @@
 module SDN
   class Message
-    class GetMotorPosition < SimpleRequest
-      MSG = 0x0c
-    end
+    class GetGroupAddr < Message
+      MSG = 0x41
+      PARAMS_LENGTH = 1
 
-    class GetMotorStatus < SimpleRequest
-      MSG = 0x0e
-    end
+      attr_reader :group_index
 
-    class GetMotorLimits < SimpleRequest
-      MSG = 0x21
+      def initialize(dest = nil, group_index = 1, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.group_index = group_index
+      end
+
+      def parse(params)
+        super
+        self.group_index = to_number(params[0]) + 1
+      end
+
+      def group_index=(value)
+        raise ArgumentError, "group_index is out of range" unless (1..16).include?(value)
+        @group_index = value
+      end
+
+      def params
+        transform_param(group_index - 1)
+      end
     end
 
     class GetMotorDirection < SimpleRequest
       MSG = 0x22
     end
 
-    class GetMotorRollingSpeed < SimpleRequest
-      MSG = 0x23
-    end
-
     class GetMotorIP < Message
       MSG = 0x25
       PARAMS_LENGTH = 1
 
       attr_reader :ip
 
-      def initialize(dest = nil, ip = nil, **kwargs)
+      def initialize(dest = nil, ip = 1, **kwargs)
         kwargs[:dest] ||= dest
         super(**kwargs)
         self.ip = ip
@@ -34,48 +45,37 @@ module SDN
 
       def parse(params)
         super
-        self.ip = to_number(params[0], nillable: true)
+        self.ip = to_number(params[0])
       end
 
       def ip=(value)
-        raise ArgumentError, "invalid IP #{ip} (should be 1-16)" unless ip.nil? || (1..16).include?(ip)
+        raise ArgumentError, "invalid IP #{value} (should be 1-16)" unless (1..16).include?(value)
         @ip = value
       end
 
       def params
-        transform_param(@ip || 0xff)
+        transform_param(ip)
       end
     end
 
-    class GetGroupAddr < Message
-      MSG = 0x41
-      PARAMS_LENGTH = 1
-
-      attr_reader :group_index
-
-      def initialize(dest = nil, group_index = 0, **kwargs)
-        kwargs[:dest] ||= dest
-        super(**kwargs)
-        self.group_index = group_index
-      end
+    class GetMotorLimits < SimpleRequest
+      MSG = 0x21
+    end
 
-      def parse(params)
-        super
-        self.group_index = to_number(params[0])
-      end
+    class GetMotorPosition < SimpleRequest
+      MSG = 0x0c
+    end
 
-      def group_index=(value)
-        raise ArgumentError, "group_index is out of range" unless (0...16).include?(value)
-        @group_index = value
-      end
+    class GetMotorRollingSpeed < SimpleRequest
+      MSG = 0x23
+    end
 
-      def params
-        transform_param(group_index)
-      end
+    class GetMotorStatus < SimpleRequest
+      MSG = 0x0e
     end
 
-    class GetNodeLabel < SimpleRequest
-      MSG = 0x45
+    class GetNetworkLock < SimpleRequest
+      MSG = 0x26
     end
 
     class GetNodeAddr < Message
@@ -88,6 +88,14 @@ module SDN
       end
     end
 
+    class GetNodeAppVersion < SimpleRequest
+      MSG = 0x74
+    end
+
+    class GetNodeLabel < SimpleRequest
+      MSG = 0x45
+    end
+
     class GetNodeSerialNumber < SimpleRequest
       MSG = 0x4c
     end