somfy_sdn 1.0.12 → 2.0.0

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

@@ -13,6 +13,34 @@ module SDN
         addr_bytes[0..1] == [1, 1]
       end
 
+      def node_type_from_number(number)
+        case number
+        when 1; :st50ilt2
+        when 2; :st30
+        when 6; :glydea
+        when 7; :st50ac
+        when 8; :st50dc
+        when 0x70; :lt50
+        else; number
+        end
+      end
+
+      def node_type_to_number(type)
+        case type
+        when :st50ilt2; 1
+        when :st30; 2
+        when :glydea; 6
+        when :st50ac; 7
+        when :st50dc; 8
+        when :lt50; 0x70
+        else; type
+        end
+      end
+
+      def node_type_to_string(type)
+        type.is_a?(Integer) ? "%02xh" % type : type.inspect
+      end
+
       def transform_param(param)
         Array(param).reverse.map { |byte| 0xff - byte }
       end
@@ -23,7 +51,9 @@ module SDN
         result
       end
 
-      def from_number(number, bytes)
+      def from_number(number, bytes = 1)
+        number ||= 1 ** (bytes * 8) - 1
+        number = number.to_i
         bytes.times.inject([]) do |res, _|
           res << (0xff - number & 0xff)
           number >>= 8
@@ -33,12 +63,12 @@ module SDN
 
       def to_string(param)
         chars = param.map { |b| 0xff - b }
-        chars[0..-1].pack("C*").sub(/\0+$/, '')
+        chars.pack("C*").sub(/\0+$/, '').strip
       end
 
       def from_string(string, bytes)
         chars = string.bytes
-        chars = chars[0...16].fill(0, chars.length, bytes - chars.length)
+        chars = chars[0...bytes].fill(' '.ord, chars.length, bytes - chars.length)
         chars.map { |b| 0xff - b }
       end
 

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

@@ -0,0 +1,48 @@
+module SDN
+  class Message
+    module ILT2
+      class GetIRConfig < SimpleRequest
+        MSG = 0x49
+      end
+
+      class GetLockStatus < SimpleRequest
+        MSG = 0x4b
+      end
+
+      class GetMotorIP < Message
+        MSG = 0x43
+        PARAMS_LENGTH = 1
+
+        attr_reader :ip
+
+        def initialize(dest = nil, ip = 1, **kwargs)
+          kwargs[:dest] ||= dest
+          super(**kwargs)
+          self.ip = ip
+        end
+
+        def ip=(value)
+          raise ArgumentError, "invalid IP #{value} (should be 1-16)" unless (1..16).include?(value)
+          @ip = value
+        end
+  
+        def parse(params)
+          super
+          self.ip = to_number(params[0]) + 1
+        end
+  
+        def params
+          transform_param(@ip - 1)
+        end
+      end
+
+      class GetMotorPosition < SimpleRequest
+        MSG = 0x44
+      end
+
+      class GetMotorSettings < SimpleRequest
+        MSG = 0x42
+      end
+    end
+  end
+end

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