somfy_sdn 1.0.11 → 2.1.1

data/lib/sdn/cli/simulator.rb

@@ -0,0 +1,197 @@
+module SDN
+  module CLI
+    class Simulator
+      class MockMotor
+        attr_accessor :address, :node_type, :label, :ips, :position_pulses, :up_limit, :down_limit, :groups, :network_lock_priority, :lock_priority, :ir_channels
+
+        def initialize(client)
+          @client = client
+          self.address = Message.parse_address("00.00.00")
+          self.node_type = :st30
+          self.label = ""
+          self.ips = Array.new(16)
+          self.groups = Array.new(16)
+          self.ir_channels = 0
+          self.lock_priority = 0
+        end
+
+        def process
+          loop do
+            @client.receive do |message|
+              SDN.logger.info "Received #{message.inspect}"
+              next unless message.is_a?(Message::ILT2::MasterControl) ||
+                message.dest == address ||
+                message.dest == BROADCAST_ADDRESS
+          
+              case message
+              when Message::GetGroupAddr
+                next nack(message) unless (1..16).include?(message.group_index)
+                respond(message.src, Message::PostGroupAddr.new(message.group_index, groups[message.group_index - 1]))
+              when Message::GetMotorIP
+                next nack(message) unless (1..16).include?(message.ip)
+                respond(message.src, Message::PostMotorIP.new(message.ip, ips[message.ip - 1], to_percent(ips[message.ip - 1])))
+              when Message::GetMotorLimits
+                respond(message.src, Message::PostMotorLimits.new(up_limit, down_limit))
+              when Message::GetMotorPosition
+                respond(message.src, Message::PostMotorPosition.new(
+                  position_pulses,
+                  to_percent(position_pulses),
+                  ips.index(position_pulses)&.+(1)
+                ))
+              when Message::GetNodeAddr; respond(message.src, Message::PostNodeAddr.new)
+              when Message::GetNodeLabel; respond(message.src, Message::PostNodeLabel.new(label))
+              when Message::ILT2::GetIRConfig; respond(message.src, Message::ILT2::PostIRConfig.new(ir_channels))
+              when Message::ILT2::GetLockStatus; respond(message.src, Message::ILT2::PostLockStatus.new(lock_priority))
+              when Message::ILT2::GetMotorIP; respond(message.src, Message::ILT2::PostMotorIP.new(message.ip, ips[message.ip - 1]))
+              when Message::ILT2::GetMotorPosition; respond(message.src, Message::ILT2::PostMotorPosition.new(position_pulses, to_percent(position_pulses)))
+              when Message::ILT2::GetMotorSettings; respond(message.src, Message::ILT2::PostMotorSettings.new(down_limit))
+              when Message::ILT2::SetIRConfig; self.ir_channels = message.channels
+              when Message::ILT2::SetLockStatus; self.lock_priority = message.priority
+              when Message::ILT2::SetMotorIP
+                next nack(message) unless (1..16).include?(message.ip)
+                ips[message.ip - 1] = message.value
+                ack(message)
+              when Message::ILT2::SetMotorPosition
+                next nack(message) unless down_limit
+
+                self.position_pulses = case message.target_type
+                when :up_limit; 0
+                when :down_limit; down_limit
+                when :ip
+                  next nack(message) unless (1..16).include?(message.target)
+                  next nack(message) unless ips[message.target]
+                  ips[message.target]
+                when :position_pulses
+                  next nack(message) if message.target - 1 > down_limit
+                  message.target - 1
+                when :jog_up_pulses; [0, position_pulses - message.target].max
+                when :jog_down_pulses; [down_limit, position_pulses + message.target].min
+                when :position_percent
+                  next nack(message) if message.target > 100
+                  to_pulses(message.target.to_f)
+                end
+                ack(message)
+              when Message::ILT2::SetMotorSettings
+                if message.down_limit != 0
+                  self.down_limit = message.down_limit
+                  self.position_pulses = message.position_pulses
+                end
+              when Message::MoveTo
+                next nack(message) unless down_limit
+                next nack(message) unless %I{up_limit down_limit ip position_pulses position_percent}.include?(message.target_type)
+                
+                self.position_pulses = case message.target_type
+                when :up_limit; 0
+                when :down_limit; down_limit;
+                when :ip
+                  next nack(message) unless (1..16).include?(message.target)
+                  next nack(message) unless ips[message.target - 1]
+                  ips[message.target - 1]
+                when :position_pulses
+                  next nack(message) if message.target > down_limit
+                  message.target
+                when :position_percent
+                  next nack(message) if message.target > 100
+                  to_pulses(message.target)
+                end
+                ack(message)
+              when Message::SetGroupAddr
+                next nack(message) unless (1..16).include?(message.group_index)
+                groups[message.group_index - 1] = message.group_address == [0, 0, 0] ? nil : message.group_address
+                ack(message)
+              when Message::SetMotorIP
+                next nack(message) unless (1..16).include?(message.ip) || message.type == :distribute
+
+                case message.type
+                when :delete
+                  ips[message.ip - 1] = nil
+                  ack(message)
+                when :current_position
+                  ips[message.ip - 1] = position_pulses
+                  ack(message)
+                when :position_pulses
+                  ips[message.ip - 1] = message.value
+                  ack(message)
+                when :position_percent
+                  pulses = to_pulses(message.value)
+                  if pulses
+                    ips[message.ip - 1] = pulses
+                    ack(message)
+                  else
+                    nack(message)
+                  end
+                when :distribute
+                  next nack(message) unless down_limit
+                  next nack(message) unless (1..15).include?(message.value)
+                  span = down_limit / (message.value + 1)
+                  current = 0
+                  (0...message.value).each do |ip|
+                    ips[ip] = (current += span)
+                  end
+                  (message.value...16).each do |ip|
+                    ips[ip] = nil
+                  end
+                  ack(message)
+                end
+              when Message::SetMotorLimits
+                next nack(message) unless [:up, :down].include?(message.target)
+                next nack(message) unless [:jog_pulses].include?(message.type)
+
+                self.up_limit ||= 0
+                self.down_limit ||= 0
+                self.position_pulses ||= 0
+
+                next nack(message) if message.target == :up && position_pulses != 0
+                next nack(message) if message.target == :down && position_pulses != down_limit
+
+                case message.type
+                when :jog_pulses
+                  self.down_limit += message.value
+                  self.position_pulses += message.value if message.target == :down
+                end
+                ack(message)
+              when Message::SetNodeLabel; self.label = message.label; ack(message)
+              end
+            end
+          end
+        end
+
+        def to_percent(pulses)
+          pulses && down_limit ? 100.0 * pulses / down_limit : nil
+        end
+
+        def to_pulses(percent)
+          percent && down_limit ? down_limit * percent / 100 : nil
+        end
+
+        def ack(message)
+          return unless message.ack_requested
+          respond(Message::Ack.new(message.dest))
+        end
+
+        def nack(message, error_code = nil)
+          return unless message.ack_requested
+          respond(Message::Nack.new(message.dest))
+        end
+
+        def respond(dest, message)
+          message.src = address
+          message.node_type = node_type
+          message.dest = dest
+          SDN.logger.info "Sending #{message.inspect}"
+          @client.send(message)
+        end
+      end
+
+      def initialize(port, address = nil)
+        sdn = Client.new(port)
+
+        motor = MockMotor.new(sdn)
+        motor.address = Message.parse_address(address) if address
+        motor.node_type = :lt50
+
+        motor.process
+      end
+    end
+  end
+end

data/lib/sdn/client.rb

@@ -0,0 +1,86 @@
+require 'io/wait'
+
+module SDN
+  class Client
+    def initialize(port)
+      uri = URI.parse(port)
+      @io = if uri.scheme == "tcp"
+        require 'socket'
+        TCPSocket.new(uri.host, uri.port)
+      elsif uri.scheme == "telnet" || uri.scheme == "rfc2217"
+        require 'net/telnet/rfc2217'
+        Net::Telnet::RFC2217.new(host: uri.host,
+         port: uri.port || 23,
+         baud: 4800,
+         data_bits: 8,
+         parity: :odd,
+         stop_bits: 1)
+      elsif port == "/dev/ptmx"
+        require 'pty'
+        io, slave = PTY.open
+        puts "Slave PTY available at #{slave.path}"
+        io
+      else
+        require 'ccutrer-serialport'
+        CCutrer::SerialPort.new(port, baud: 4800, data_bits: 8, parity: :odd, stop_bits: 1)
+      end
+      @buffer = ""
+    end
+
+    def send(message)
+      @io.write(message.serialize)
+    end
+
+    def transact(message)
+      message.ack_requested = true
+      send(message)
+      receive(1)
+    end
+
+    def ensure(message)
+      loop do
+        messages = transact(message)
+        next if messages.empty?
+        next unless message.class.expected_response?(messages.first)
+        return messages.first
+      end
+    end
+
+    WAIT_TIME = 0.25
+
+    def receive(timeout = nil)
+      messages = []
+
+      loop do
+        message, bytes_read = Message.parse(@buffer.bytes)
+        # discard how much we read
+        @buffer = @buffer[bytes_read..-1] if bytes_read
+        unless message
+          break unless messages.empty?
+
+          begin
+            block = @io.read_nonblock(64 * 1024)
+            SDN.logger.debug "read #{block.unpack("H*").first.gsub(/\h{2}/, "\\0 ")}"
+            @buffer.concat(block)
+            next
+          rescue IO::WaitReadable, EOFError
+            wait = @buffer.empty? ? timeout : WAIT_TIME
+            if @io.wait_readable(wait).nil?
+              # timed out; just discard everything
+              SDN.logger.debug "discarding #{@buffer.unpack("H*").first.gsub(/\h{2}/, "\\0 ")} due to timeout"
+              @buffer = ""
+            end
+          end
+          next
+        end
+        if block_given?
+          yield message
+        else
+          messages << message
+        end
+      end
+
+      messages
+    end
+  end
+end

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

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