somfy_sdn 1.0.12 → 2.0.0

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

@@ -1,44 +1,68 @@
 module SDN
   class Message
-    class PostMotorPosition < Message
-      MSG = 0x0d
-      PARAMS_LENGTH = 5
+    class PostGroupAddr < Message
+      MSG = 0x61
+      PARAMS_LENGTH = 4
 
-      attr_accessor :position_pulses, :position_percent, :ip
+      def initialize(group_index = nil, group_address = nil, **kwargs)
+        super(**kwargs)
+        self.group_index = group_index
+        self.group_address = group_address
+      end
+
+      attr_accessor :group_index, :group_address
 
       def parse(params)
         super
-        self.position_pulses = to_number(params[0..1], nillable: true)
-        self.position_percent = to_number(params[2], nillable: true)
-        self.ip = to_number(params[4], nillable: true)
+        self.group_index = to_number(params[0]) + 1
+        self.group_address = transform_param(params[1..3])
+        self.group_address = nil if group_address == [0, 0, 0] || group_address == [0x01, 0x01, 0xff]
+      end
+
+      def params
+        from_number(group_index - 1) + transform_param(group_address || [0, 0, 0])
+      end
+
+      def class_inspect
+        ", group_index=#{group_index.inspect}, group_address=#{group_address ? print_address(group_address) : 'nil'}"
       end
     end
 
-    class PostMotorStatus < Message
-      MSG = 0x0f
+    class PostMotorDirection < Message
+      MSG = 0x32
+      PARAMS_LENGTH = 1
+      DIRECTION = { standard: 0x00, reversed: 0x01 }.freeze
+
+      attr_accessor :direction
+
+      def parse(params)
+        super
+        self.direction = DIRECTION.invert[to_number(params[0])]
+      end
+    end
+
+    class PostMotorIP < Message
+      MSG = 0x35
       PARAMS_LENGTH = 4
-      STATE = { stopped: 0x00, running: 0x01, blocked: 0x02, locked: 0x03 }.freeze
-      DIRECTION = { down: 0x00, up: 0x01 }.freeze
-      SOURCE = { internal: 0x00, network: 0x01, dct: 0x02 }.freeze
-      CAUSE = { target_reached: 0x00,
-                explicit_command: 0x01,
-                wink: 0x02,
-                limits_not_set: 0x10,
-                ip_not_set: 0x11,
-                polarity_not_checked: 0x12,
-                in_configuration_mode: 0x13,
-                obstacle_detection: 0x20,
-                over_current_protection: 0x21,
-                thermal_protection: 0x22 }.freeze
 
-      attr_accessor :state, :last_direction, :last_action_source, :last_action_cause
+      attr_accessor :ip, :position_pulses, :position_percent
+
+      def initialize(ip = nil, position_pulses = nil, position_percent = nil, **kwargs)
+        super(**kwargs)
+        self.ip = ip
+        self.position_pulses = position_pulses
+        self.position_percent = position_percent
+      end
 
       def parse(params)
         super
-        self.state = STATE.invert[to_number(params[0])]
-        self.last_direction = DIRECTION.invert[to_number(params[1])]
-        self.last_action_source = SOURCE.invert[to_number(params[2])]
-        self.last_action_cause = CAUSE.invert[to_number(params[3])]
+        self.ip = to_number(params[0])
+        self.position_pulses = to_number(params[1..2], nillable: true)
+        self.position_percent = to_number(params[3], nillable: true)
+      end
+
+      def params
+        from_number(ip) + from_number(position_pulses, 2) + from_number(position_percent)
       end
     end
 
@@ -48,23 +72,45 @@ module SDN
 
       attr_accessor :up_limit, :down_limit
 
+      def initialize(up_limit = nil, down_limit = nil, **kwargs)
+        super(**kwargs)
+        self.up_limit = up_limit
+        self.down_limit = down_limit
+      end
+
       def parse(params)
         super
         self.up_limit = to_number(params[0..1], nillable: true)
         self.down_limit = to_number(params[2..3], nillable: true)
       end
+
+      def params
+        from_number(up_limit, 2) + from_number(down_limit, 2)
+      end
     end
 
-    class PostMotorDirection < Message
-      MSG = 0x32
-      PARAMS_LENGTH = 1
-      DIRECTION = { standard: 0x00, reversed: 0x01 }.freeze
+    class PostMotorPosition < Message
+      MSG = 0x0d
+      PARAMS_LENGTH = 5
 
-      attr_accessor :direction
+      attr_accessor :position_pulses, :position_percent, :ip
+
+      def initialize(position_pulses = nil, position_percent = nil, ip = nil, **kwargs)
+        super(**kwargs)
+        self.position_pulses = position_pulses
+        self.position_percent = position_percent
+        self.ip = ip
+      end
 
       def parse(params)
         super
-        self.direction = DIRECTION.invert[to_number(params[0])]
+        self.position_pulses = to_number(params[0..1], nillable: true)
+        self.position_percent = to_number(params[2], nillable: true)
+        self.ip = to_number(params[4], nillable: true)
+      end
+
+      def params
+        from_number(position_pulses, 2) + from_number(position_percent) + from_number(ip)
       end
     end
 
@@ -83,17 +129,40 @@ module SDN
       end
     end
 
-    class PostMotorIP < Message
-      MSG = 0x35
+    class PostMotorStatus < Message
+      MSG = 0x0f
       PARAMS_LENGTH = 4
+      STATE = { stopped: 0x00, running: 0x01, blocked: 0x02, locked: 0x03 }.freeze
+      DIRECTION = { down: 0x00, up: 0x01 }.freeze
+      SOURCE = { internal: 0x00, network: 0x01, dct: 0x02 }.freeze
+      CAUSE = { target_reached: 0x00,
+                explicit_command: 0x01,
+                wink: 0x02,
+                limits_not_set: 0x10,
+                ip_not_set: 0x11,
+                polarity_not_checked: 0x12,
+                in_configuration_mode: 0x13,
+                obstacle_detection: 0x20,
+                over_current_protection: 0x21,
+                thermal_protection: 0x22 }.freeze
 
-      attr_accessor :ip, :position_pulses, :position_percent
+      attr_accessor :state, :last_direction, :last_action_source, :last_action_cause
+
+      def parse(params)
+        super
+        self.state = STATE.invert[to_number(params[0])]
+        self.last_direction = DIRECTION.invert[to_number(params[1])]
+        self.last_action_source = SOURCE.invert[to_number(params[2])]
+        self.last_action_cause = CAUSE.invert[to_number(params[3])]
+      end
+    end
+
+    class PostNetworkLock < UnknownMessage
+      MSG = 0x36
+      PARAMS_LENGTH = 5
 
       def parse(params)
         super
-        self.ip = to_number(params[0])
-        self.position_pulses = to_number(params[1..2], nillable: true)
-        self.position_percent = to_number(params[3], nillable: true)
       end
     end
 
@@ -102,32 +171,39 @@ module SDN
       PARAMS_LENGTH = 0
     end
 
-    class PostGroupAddr < Message
-      MSG = 0x61
-      PARAMS_LENGTH = 4
+    class PostNodeAppVersion < Message
+      MSG = 0x75
+      PARAMS_LENGTH = 6
 
-      attr_accessor :group_index, :group_address
+      attr_accessor :reference, :index_letter, :index_number, :profile
 
       def parse(params)
         super
-        self.group_index = to_number(params[0])
-        self.group_address = transform_param(params[1..3])
-        self.group_address = nil if group_address == [0, 0, 0] || group_address == [0x01, 0x01, 0xff]
-      end
-
-      def class_inspect
-        ", group_index=#{group_index.inspect}, group_address=#{group_address ? print_address(group_address) : 'nil'}"
+        self.reference = to_number(params[0..2])
+        self.index_letter = to_string(params[3..3])
+        self.index_number = transform_param(params[4])
+        self.profile = transform_param(params[5])
       end
     end
 
     class PostNodeLabel < Message
       MSG = 0x65
+      MAX_LENGTH = 16
 
       attr_accessor :label
 
+      def initialize(label = nil, **kwargs)
+        super(**kwargs)
+        self.label = label
+      end
+
       def parse(params)
         @label = to_string(params)
       end
+
+      def params
+        from_string(label, self.class::MAX_LENGTH)
+      end
     end
 
     class PostNodeSerialNumber < Message
@@ -145,18 +221,8 @@ module SDN
       end
     end
 
-    class PostNodeStackVersion < UnknownMessage
+    class PostNodeStackVersion < PostNodeAppVersion
       MSG = 0x71
-
-      attr_accessor :params
-
-      def parse(params)
-        # I don't know how to interpret this yet
-        # I get b6 bc b2 be fc fe, and UAI+ shows 5063497A3
-        super
-      end
-
-      def msg; MSG; end
     end
   end
 end

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

@@ -1,46 +1,67 @@
 module SDN
   class Message
-    class SetMotorLimits < Message
-      MSG = 0x11
-      PARAMS_LENGTH = 4
-      TYPE = { delete: 0x00, current_position: 0x01, specified_position: 0x02, jog_ms: 0x04, jog_pulses: 0x05 }
-      TARGET = { down: 0x00, up: 0x01 }
+    class SetFactoryDefault < Message
+      MSG = 0x1f
+      PARAMS_LENGTH = 1
+      RESET = { all_settings: 0x00, group_addresses: 0x01, limits: 0x11, rotation: 0x12, rolling_speed: 0x13, ips: 0x15, locks: 0x17 }
 
-      attr_reader :type, :target, :value
+      attr_reader :reset
 
-      def initialize(dest = nil, type = :delete, target = :up, value = nil, **kwargs)
-        kwargs[:dest] = dest
+      def initialize(dest = nil, reset = :all_settings, **kwargs)
+        kwargs[:dest] ||= dest
         super(**kwargs)
-        self.type = type
-        self.target = target
-        self.value = value
+        self.reset = reset
       end
 
       def parse(params)
         super
-        self.type = TYPE.invert[to_number(params[0])]
-        self.target = TARGET.invert[to_number(params[1])]
-        self.value = to_number(params[2..3])
+        self.reset = RESET.invert[to_number(params)]
       end
 
-      def type=(value)
-        raise ArgumentError, "type must be one of :delete, :current_position, :specified_position, :jog_ms, :jog_pulses" unless TYPE.keys.include?(value)
-        @type = value
+      def reset=(value)
+        raise ArgumentError, "reset must be one of :all_settings, :group_addresses, :limits, :rotation, :rolling_speed, :ips, :locks" unless RESET.keys.include?(value)
+        @reset = value
       end
 
-      def target=(value)
-        raise ArgumentError, "target must be one of :up, :down" unless TARGET.keys.include?(value)
-        @target = value
+      def params
+        transform_param(RESET[reset])
       end
+    end
 
-      def value=(value)
-        @value = value&. & 0xffff
+    class SetGroupAddr < Message
+      MSG = 0x51
+      PARAMS_LENGTH = 4
+
+      attr_reader :group_index, :group_address
+
+      def initialize(dest = nil, group_index = 1, group_address = nil, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.group_index = group_index
+        self.group_address = group_address
+      end
+
+      def parse(params)
+        super
+        self.group_index = to_number(params[0]) + 1
+        self.group_address = transform_param(params[1..3])
+      end
+
+      def group_index=(value)
+        raise ArgumentError, "group_index is out of range" unless (1..16).include?(value)
+        @group_index = value
+      end
+
+      def group_address=(value)
+        @group_address = value
       end
 
       def params
-        param = value || 0
-        param /= 10 if target == :jog_ms
-        transform_param(TYPE[type]) + transform_param(TARGET[target]) + from_number(param, 2)
+        transform_param(group_index - 1) + transform_param(group_address || [0, 0, 0])
+      end
+
+      def class_inspect
+        ", group_index=#{group_index.inspect}, group_address=#{group_address ? print_address(group_address) : 'nil'}"
       end
     end
 
@@ -72,31 +93,6 @@ module SDN
       end
     end
 
-    class SetMotorRollingSpeed < Message
-      MSG = 0x13
-      PARAMS_LENGTH = 3
-
-      attr_accessor :up_speed, :down_speed, :slow_speed
-      def initialize(dest = nil, up_speed: nil, down_speed: nil, slow_speed: nil, **kwargs)
-        kwargs[:dest] ||= dest
-        super(**kwargs)
-        self.up_speed = up_speed
-        self.down_speed = down_speed
-        self.slow_speed = slow_speed
-      end
-
-      def parse(params)
-        super
-        self.up_speed = to_number(params[0])
-        self.down_speed = to_number(params[1])
-        self.slow_speed = to_number(params[2])
-      end
-
-      def params
-        transform_param(up_speed || 0xff) + transform_param(down_speed || 0xff) + transform_param(slow_speed || 0xff)
-      end
-    end
-
     class SetMotorIP < Message
       MSG = 0x15
       PARAMS_LENGTH = 4
@@ -141,74 +137,93 @@ module SDN
       end
     end
 
-    class SetFactoryDefault < Message
-      MSG = 0x1f
-      PARAMS_LENGTH = 1
-      RESET = { all_settings: 0x00, group_addresses: 0x01, limits: 0x11, rotation: 0x12, rolling_speed: 0x13, ips: 0x15, locks: 0x17 }
+    class SetMotorLimits < Message
+      MSG = 0x11
+      PARAMS_LENGTH = 4
+      TYPE = { delete: 0x00, current_position: 0x01, specified_position: 0x02, jog_ms: 0x04, jog_pulses: 0x05 }
+      TARGET = { down: 0x00, up: 0x01 }
 
-      attr_reader :reset
+      attr_reader :type, :target, :value
 
-      def initialize(dest = nil, reset = :all_settings, **kwargs)
+      def initialize(dest = nil, type = :delete, target = :up, value = nil, **kwargs)
         kwargs[:dest] ||= dest
         super(**kwargs)
-        self.reset = reset
+        self.type = type
+        self.target = target
+        self.value = value
       end
 
       def parse(params)
         super
-        self.reset = RESET.invert[to_number(params)]
+        self.type = TYPE.invert[to_number(params[0])]
+        self.target = TARGET.invert[to_number(params[1])]
+        self.value = to_number(params[2..3])
       end
 
-      def reset=(value)
-        raise ArgumentError, "reset must be one of :all_settings, :group_addresses, :limits, :rotation, :rolling_speed, :ips, :locks" unless RESET.keys.include?(value)
-        @reset = value
+      def type=(value)
+        raise ArgumentError, "type must be one of :delete, :current_position, :specified_position, :jog_ms, :jog_pulses" unless TYPE.keys.include?(value)
+        @type = value
+      end
+
+      def target=(value)
+        raise ArgumentError, "target must be one of :up, :down" unless TARGET.keys.include?(value)
+        @target = value
+      end
+
+      def value=(value)
+        @value = value&. & 0xffff
       end
 
       def params
-        transform_param(RESET[reset])
+        param = value || 0
+        param /= 10 if target == :jog_ms
+        transform_param(TYPE[type]) + transform_param(TARGET[target]) + from_number(param, 2)
       end
     end
 
-    class SetGroupAddr < Message
-      MSG = 0x51
-      PARAMS_LENGTH = 4
-
-      attr_reader :group_index, :group_address
+    class SetMotorRollingSpeed < Message
+      MSG = 0x13
+      PARAMS_LENGTH = 3
 
-      def initialize(dest = nil, group_index = 0, group_address = nil, **kwargs)
+      attr_accessor :up_speed, :down_speed, :slow_speed
+      def initialize(dest = nil, up_speed: nil, down_speed: nil, slow_speed: nil, **kwargs)
         kwargs[:dest] ||= dest
         super(**kwargs)
-        self.group_index = group_index
-        self.group_address = group_address
+        self.up_speed = up_speed
+        self.down_speed = down_speed
+        self.slow_speed = slow_speed
       end
 
       def parse(params)
         super
-        self.group_index = to_number(params[0])
-        self.group_address = transform_param(params[1..3])
+        self.up_speed = to_number(params[0])
+        self.down_speed = to_number(params[1])
+        self.slow_speed = to_number(params[2])
       end
 
-      def group_index=(value)
-        raise ArgumentError, "group_index is out of range" unless (0...16).include?(value)
-        @group_index = value
+      def params
+        transform_param(up_speed || 0xff) + transform_param(down_speed || 0xff) + transform_param(slow_speed || 0xff)
       end
+    end
 
-      def group_address=(value)
-        @group_address = value
-      end
+    class SetNetworkLock < Message
+      MSG = 0x16
 
-      def params
-        transform_param(group_index) + transform_param(group_address || [0, 0, 0])
+      attr_accessor :locked, :priority
+
+      def parse(params)
+        self.locked = to_number(params[0]) == 1 ? true : false
+        self.priority = to_number(params[1])
       end
 
-      def class_inspect
-        ", group_index=#{group_index.inspect}, group_address=#{group_address ? print_address(group_address) : 'nil'}"
+      def params
+        transform_param(locked ? 1 : 0) + transform_param(priority)
       end
     end
 
     class SetNodeLabel < Message
       MSG = 0x55
-      PARAMS_LENGTH = 16
+      MAX_LENGTH = 16
 
       attr_accessor :label
 
@@ -223,7 +238,7 @@ module SDN
       end
 
       def params
-        from_string(label, 16)
+        from_string(label, self.class::MAX_LENGTH)
       end
     end
   end