somfy_sdn 1.0.12 → 2.0.0

data/lib/sdn/cli/provisioner.rb

@@ -0,0 +1,234 @@
+require 'curses'
+
+module SDN
+  module CLI
+    class Provisioner
+      attr_reader :win, :sdn, :addr, :ns
+
+      def initialize(port, addr = nil)
+        @sdn = Client.new(port)
+        @reversed = false
+        @pulse_count = 10
+
+        if addr
+          @addr = addr = Message.parse_address(addr)
+        else
+          puts "Discovering motor..."
+          message = sdn.ensure(Message::GetNodeAddr.new)
+          puts "Found #{message.node_type}"
+          @addr = addr = message.src
+        end
+
+        puts "Preparing to provision motor #{Message.print_address(addr)}"
+
+        message = sdn.ensure(Message::GetNodeLabel.new(addr))
+
+        node_type = message.node_type
+        @ns = ns = node_type == :st50ilt2 ? Message::ILT2 : Message
+
+        print "Motor is currently labeled '#{message.label}'; what would you like to change it to (blank to leave alone)? "
+        new_label = STDIN.gets
+
+        unless new_label == "\n"
+          new_label.strip!
+          sdn.ensure(ns::SetNodeLabel.new(addr, new_label))
+        end
+
+        # make sure some limits exist
+        unless ns == Message::ILT2
+          limits = sdn.ensure(Message::GetMotorLimits.new(addr))
+          if limits.up_limit.nil? || limits.down_limit.nil?
+            sdn.ensure(Message::SetMotorLimits.new(addr, :delete, :up))
+            sdn.ensure(Message::SetMotorLimits.new(addr, :delete, :down))
+            sdn.ensure(Message::SetMotorLimits.new(addr, :current_position, :up))
+            sdn.ensure(Message::SetMotorLimits.new(addr, :specified_position, :down, 500))
+          end
+        end
+
+        Curses.init_screen
+        begin
+          Curses.noecho
+          Curses.crmode
+          Curses.nonl
+          Curses.curs_set(0)
+          @win = Curses.stdscr
+      
+          process
+        rescue => e
+          win.setpos(0, 0)
+          win.addstr(e.inspect)
+          win.addstr("\n")
+          win.addstr(e.backtrace.join("\n"))
+          win.refresh
+          sleep 10
+        ensure
+          Curses.close_screen
+        end
+      end
+
+      def process
+        win.keypad = true
+        print_help
+        refresh
+
+        loop do
+          char = win.getch
+          case char
+          when 27 # Esc
+            stop
+            refresh
+          when Curses::Key::UP
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :up_limit))
+            else
+              sdn.ensure(Message::MoveTo.new(addr, :up_limit))
+            end
+            wait_for_stop
+          when Curses::Key::DOWN
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :down_limit))
+            else
+              sdn.ensure(Message::MoveTo.new(addr, :down_limit))
+            end
+            wait_for_stop
+          when Curses::Key::LEFT
+            if @pos < @pulse_count
+              sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @limit + @pulse_count - @pos, @pulse_count))
+              refresh
+            end
+            sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :jog_up_pulses, @pulse_count))
+            wait_for_stop
+          when Curses::Key::RIGHT
+            if @limit - @pos < @pulse_count
+              sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @pos + @pulse_count, @pos))
+              refresh
+            end
+            sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :jog_down_pulses, @pulse_count))
+            wait_for_stop
+          when 'u'
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @limit - @pos, 0))
+            else
+              sdn.ensure(Message::SetMotorLimits.new(addr, :current_position, :up))
+            end
+            refresh
+          when 'l'
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @pos, @pos))
+            else
+              sdn.ensure(Message::SetMotorLimits.new(addr, :current_position, :down))
+            end
+            refresh
+          when 'r'
+            @reversed = !@reversed
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @limit, @limit - @pos))
+            else
+              sdn.ensure(Message::SetMotorDirection.new(addr, @reversed ? :reversed : :standard))
+            end
+            refresh
+          when 'R'
+            next unless ilt2?
+            @reversed = !@reversed
+            sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @limit, @pos))
+            refresh
+          when '<'
+            @pulse_count /= 2 if @pulse_count > 5
+            print_help
+          when '>'
+            @pulse_count *= 2
+            print_help
+          when 'q'
+            break
+          end
+        end
+      end
+
+      def print_help
+        win.setpos(0, 0)
+        win.addstr(<<-INSTRUCTIONS)
+Move the motor. Keys:
+Esc  stop movement
+\u2191    go to upper limit
+\u2193    go to lower limit
+\u2190    jog up #{@pulse_count} pulses
+\u2192    jog down #{@pulse_count} pulses
+>    increase jog size
+<    decrease jog size
+u    set upper limit at current position
+l    set lower limit at current position
+r    reverse motor
+        INSTRUCTIONS
+
+        if ilt2?
+          win.addstr("R    reverse motor (but leave position alone)\n")
+        end
+        win.addstr("q    quit\n")
+        win.refresh
+      end
+      
+      def wait_for_stop
+        win.setpos(13, 0)
+        win.addstr("Moving...\n")
+        loop do
+          win.nodelay = true
+          stop if win.getch == 27 # Esc
+          sdn.send(ns::GetMotorPosition.new(addr))
+          sdn.receive do |message|
+            next unless message.is_a?(ns::PostMotorPosition)
+            last_pos = @pos
+            @pos = message.position_pulses
+            win.setpos(14, 0)
+            win.addstr("Position: #{@pos}\n")
+
+            if last_pos == @pos
+              win.setpos(13, 0)
+              win.addstr("\n")
+              win.nodelay = false
+              refresh
+              return
+            end
+          end
+          sleep 0.1
+          
+        end
+      end
+
+      def refresh
+        pos = sdn.ensure(ns::GetMotorPosition.new(addr))
+        @pos = pos.position_pulses
+        if ilt2?
+          settings = sdn.ensure(Message::ILT2::GetMotorSettings.new(addr))
+          @limit = settings.limit
+        else
+          limits = sdn.ensure(Message::GetMotorLimits.new(addr))
+          @limit = limits.down_limit
+          direction = sdn.ensure(Message::GetMotorDirection.new(addr))
+          @reversed = direction.direction == :reversed
+        end
+
+        win.setpos(14, 0)
+        win.addstr("Position: #{@pos}\n")
+        win.addstr("Limit: #{@limit}\n")
+        win.addstr("Reversed: #{@reversed}\n")
+        win.refresh
+      end
+
+      def stop
+        if ilt2?
+          sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :stop))
+        else
+          sdn.ensure(Message::Stop.new(addr))
+        end
+      end
+
+      def ilt2?
+        ns == Message::ILT2
+      end
+
+      def reversed_int
+        @reversed ? 1 : 0
+      end
+    end
+  end
+end

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,84 @@
+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,
+         'parity' => Net::Telnet::RFC2217::ODD)
+      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