somfy_sdn 1.0.12 → 2.1.2

data/lib/sdn/message/ilt2/master_control.rb

@@ -0,0 +1,35 @@
+module SDN
+  class Message
+    module ILT2
+      class MasterControl
+        class << self
+          include Helpers
+
+          def parse(data)
+            return unless data.length >= 5
+            return unless checksum(data[0..2]) == data[3..4]
+            # no clue what's special about these
+            return unless data[0..1] == [0xfa, 0x7a]
+            klass = case data[2]
+              when 0x00; Down
+              when 0xfa; Up
+              when 0xff; Stop
+              end
+            return unless klass
+            [klass.new, 5]
+          end
+        end
+
+        class Down < MasterControl
+        end
+
+        class Stop < MasterControl
+        end
+ 
+        class Up < MasterControl
+        end
+
+      end
+    end
+  end
+end

data/lib/sdn/message/ilt2/post.rb

@@ -0,0 +1,127 @@
+module SDN
+  class Message
+    module ILT2
+      class PostIRConfig < Message
+        MSG = 0x69
+        PARAMS_LENGTH = 1
+
+        attr_reader :channels
+
+        def initialize(channels = nil, **kwargs)
+          super(**kwargs)
+          self.channels = channels
+        end
+
+        def channels=(value)
+          @channels = value &. & 0xff
+        end
+
+        def parse(params)
+          super
+          self.channels = to_number(params[0])
+        end
+
+        def params
+          transform_param(channels)
+        end
+
+        def class_inspect
+          ", @channels=#{channels.chr.unpack('b8').first}"
+        end
+      end
+
+      class PostLockStatus < Message
+        MSG = 0x6B
+        PARAMS_LENGTH = 1
+
+        attr_accessor :priority # 0 for not locked
+
+        def initialize(priority = nil, **kwargs)
+          super(**kwargs)
+          self.priority = priority
+        end
+
+        def parse(params)
+          super
+          self.current_lock_priority = to_number(params[0])
+        end
+
+        def params
+          transform_param(priority)
+        end
+      end
+
+      class PostMotorIP < Message
+        MSG = 0x63
+        PARAMS_LENGTH = 3
+
+        attr_accessor :ip, :position_pulses
+
+        def initialize(ip = nil, position_pulses = nil, **kwargs)
+          super(**kwargs)
+          self.ip = ip
+          self.position_pulses = position_pulses
+        end
+
+        def parse(params)
+          super
+          self.ip = to_number(params[0]) + 1
+          self.position_pulses = to_number(params[1..2], nillable: true)
+        end
+
+        def params
+          transform_param(ip - 1) + from_number(position_pulses, 2)
+        end
+      end
+
+      class PostMotorPosition < Message
+        MSG = 0x64
+        PARAMS_LENGTH = 3
+  
+        attr_accessor :position_pulses, :position_percent
+  
+        def initialize(position_pulses = nil, position_percent = nil, **kwargs)
+          super(**kwargs)
+          self.position_pulses = position_pulses
+          self.position_percent = position_percent
+        end
+
+        def parse(params)
+          super
+          self.position_pulses = to_number(params[0..1])
+          self.position_percent = to_number(params[2]).to_f / 255 * 100
+        end
+
+        def params
+          from_number(position_pulses, 2) +
+            from_number(position_percent && position_percent * 255 / 100)
+        end
+      end
+
+      class PostMotorSettings < UnknownMessage
+        MSG = 0x62
+        PARAMS_LENGTH = 3
+
+        attr_accessor :limit
+
+        def initialize(limit = nil, **kwargs)
+          super(**kwargs)
+          self.limit = limit
+        end
+
+        def parse(params)
+          super
+          self.limit = to_number(params[1..2])
+        end
+
+        def params
+          transform_param(0) + from_number(limit, 2)
+        end
+      end
+
+      class PostNodeLabel < ::SDN::Message::PostNodeLabel
+        MAX_LENGTH = 32
+      end
+    end
+  end
+end

data/lib/sdn/message/ilt2/set.rb

@@ -0,0 +1,192 @@
+module SDN
+  class Message
+    module ILT2
+      class SetIRConfig < PostIRConfig
+        MSG = 0x59
+
+        def initialize(dest = nil, channels = nil, **kwargs)
+          kwargs[:dest] ||= dest
+          super(channels, **kwargs)
+        end
+      end
+
+      class SetLockStatus < Message
+        MSG = 0x5B
+        PARAMS_LENGTH = 3
+        TARGET_TYPE = {
+          current: 0,
+          up_limit: 1,
+          down_limit: 2,
+          ip: 4,
+          unlock: 5
+        }
+
+        # when target_type is down_limit, target is number of 10ms intervals it's still allowed to roll up
+        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 parse(params)
+          super
+          self.target_type = TARGET_TYPE.invert[to_number(params[0])]
+          self.target = to_number(params[1])
+          self.priority = to_number(params[2])
+        end
+
+        def target_type=(value)
+          raise ArgumentError, "target_type must be one of :current, :up_limit, :down_limit, :ip, or :unlock" unless TARGET_TYPE.keys.include?(value)
+          @target_type = value
+        end
+
+        def target=(value)
+          @target = value&. & 0xff
+        end
+
+        def priority=(value)
+          raise ArgumentError, "priority must be between 1 and 100" unless (1..100).include?(value)
+          @priority = value
+        end
+
+        def params
+          transform_param(TARGET_TYPE[target_type]) + transform_param(target) + transform_param(priority)
+        end
+      end
+
+      class SetMotorIP < Message
+        MSG = 0x53
+        PARAMS_LENGTH = 3
+
+        attr_reader :ip, :value
+
+        def initialize(dest = nil, ip = 1, value = nil, **kwargs)
+          kwargs[:dest] ||= dest
+          super(**kwargs)
+          self.ip = ip
+          self.value = value
+        end
+
+        def parse(params)
+          super
+          self.ip = to_number(params[0]) + 1
+          self.value = to_number(params[1..2], nillable: true)
+        end
+
+        def ip=(value)
+          raise ArgumentError, "ip must be in range 1..16 or nil" unless ip.nil? || (1..16).include?(ip)
+          @ip = value
+        end
+
+        def value=(value)
+          @value = value &. & 0xffff
+        end
+
+        def params
+          transform_param(ip - 1) + from_number(value, 2)
+        end
+      end
+
+      class SetMotorLimits < UnknownMessage
+        MSG = 0x5C
+      end
+
+      class SetMotorPosition < Message
+        MSG = 0x54
+        PARAMS_LENGTH = 3
+        TARGET_TYPE = {
+          up_limit: 1,
+          down_limit: 2,
+          stop: 3,
+          ip: 4,
+          next_ip_up: 5,
+          next_ip_down: 6,
+          position_pulses: 8,
+          jog_up_ms: 10,
+          jog_down_ms: 11,
+          jog_up_pulses: 12,
+          jog_down_pulses: 13,
+          position_percent: 16,
+        }.freeze
+
+        attr_reader :target_type, :target
+
+        def initialize(dest = nil, target_type = :up_limit, target = 0, **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])
+          if target_type == :position_percent
+            target = target.to_f / 255 * 100
+          end
+          if target_type == :ip
+            target += 1
+          end
+          self.target = target
+        end
+
+        def target_type=(value)
+          raise ArgumentError, "target_type must be one of :up_limit, :down_limit, :stop, :ip, :next_ip_up, :next_ip_down, :jog_up, :jog_down, or :position_percent" unless TARGET_TYPE.keys.include?(value)
+          @target_type = value
+        end
+
+        def target=(value)
+          if target_type == :position_percent && value
+            @target = [[0, value].max, 100].min
+          else
+            @target = value&. & 0xffff
+          end
+        end
+
+        def params
+          param = target
+          param = (param * 255 / 100).to_i if target_type == :position_percent
+          param -= 1 if target_type == :ip
+          transform_param(TARGET_TYPE[target_type]) + from_number(param, 2)
+        end
+      end
+
+      # the motor does not move, and just stores the new values
+      # flags of 1 is reverse direction, but you have to set it every time
+      class SetMotorSettings < UnknownMessage
+        MSG = 0x52
+        PARAMS_LENGTH = 5
+
+        attr_accessor :flags, :down_limit, :position_pulses
+
+        def initialize(dest = nil, flags = 0, down_limit = 0, position_pulses = 0, **kwargs)
+          kwargs[:dest] ||= dest
+          super(**kwargs)
+          self.flags = flags
+          self.down_limit = down_limit
+          self.position_pulses = position_pulses
+        end
+
+        def parse(params)
+          super
+          self.flags = to_number(params[0])
+          self.down_limit = to_number(params[1..2])
+          self.position_pulses = to_number(params[3..4])
+        end
+
+        def params
+          transform_param(flags) + from_number(down_limit, 2) + from_number(position_pulses, 2)
+        end
+      end
+
+      class SetNodeLabel < ::SDN::Message::SetNodeLabel
+        MAX_LENGTH = 32
+      end
+    end
+  end
+end

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