somfy_sdn 1.0.12 → 2.1.2

data/lib/sdn/cli/mqtt.rb

@@ -0,0 +1,397 @@
+require 'mqtt'
+require 'uri'
+require 'set'
+
+require 'sdn/cli/mqtt/group'
+require 'sdn/cli/mqtt/motor'
+require 'sdn/cli/mqtt/read'
+require 'sdn/cli/mqtt/write'
+require 'sdn/cli/mqtt/subscriptions'
+
+module SDN
+  module CLI
+    class MQTT
+      MessageAndRetries = Struct.new(:message, :remaining_retries, :priority)
+
+      include Read
+      include Write
+      include Subscriptions
+
+      WAIT_TIME = 0.25
+      BROADCAST_WAIT = 5.0
+
+      attr_reader :motors, :groups
+
+      def initialize(port, mqtt_uri, device_id: "somfy", base_topic: "homie", auto_discover: true)
+        @base_topic = "#{base_topic}/#{device_id}"
+        @mqtt = ::MQTT::Client.new(mqtt_uri)
+        @mqtt.set_will("#{@base_topic}/$state", "lost", retain: true)
+        @mqtt.connect
+
+        @motors = {}
+        @groups = {}
+
+        @mutex = Mutex.new
+        @cond = ConditionVariable.new
+        @queues = [[], [], []]
+        @response_pending = false
+        @broadcast_pending = false
+
+        @auto_discover = auto_discover
+        @motors_found = true
+
+        clear_tree(@base_topic)
+        publish_basic_attributes
+
+        @sdn = Client.new(port)
+
+        read_thread = Thread.new { read }
+        write_thread = Thread.new { write }
+        @mqtt.get { |packet| handle_message(packet.topic, packet.payload) }
+      end
+
+      def publish(topic, value)
+        @mqtt.publish("#{@base_topic}/#{topic}", value, retain: true, qos: 1)
+      end
+
+      def subscribe(topic)
+        @mqtt.subscribe("#{@base_topic}/#{topic}")
+      end
+
+      def enqueue(message, queue = 0)
+        @mutex.synchronize do
+          queue = @queues[queue]
+          unless queue.include?(message)
+            queue.push(message)
+            @cond.signal
+          end
+        end
+      end
+
+      def clear_tree(topic)
+        @mqtt.subscribe("#{topic}/#")
+        @mqtt.unsubscribe("#{topic}/#", wait_for_ack: true)
+        while !@mqtt.queue_empty?
+          packet = @mqtt.get
+          @mqtt.publish(packet.topic, nil, retain: true)
+        end
+      end
+
+      def publish_basic_attributes
+        @mqtt.batch_publish do
+          publish("$homie", "4.0.0")
+          publish("$name", "Somfy SDN Network")
+          publish("$state", "init")
+          publish("$nodes", "FFFFFF")
+
+          publish("FFFFFF/$name", "Broadcast")
+          publish("FFFFFF/$type", "sdn")
+          publish("FFFFFF/$properties", "discover")
+
+          publish("FFFFFF/discover/$name", "Trigger Motor Discovery")
+          publish("FFFFFF/discover/$datatype", "enum")
+          publish("FFFFFF/discover/$format", "discover")
+          publish("FFFFFF/discover/$settable", "true")
+          publish("FFFFFF/discover/$retained", "false")
+
+          subscribe_all
+
+          publish("$state", "ready")
+        end
+
+        @mqtt.on_reconnect do
+          subscribe_all
+          publish("$state", :init)
+          publish("$state", :ready)
+        end
+      end
+
+      def subscribe_all
+        subscribe("+/discover/set")
+        subscribe("+/label/set")
+        subscribe("+/control/set")
+        subscribe("+/jog-ms/set")
+        subscribe("+/jog-pulses/set")
+        subscribe("+/position-pulses/set")
+        subscribe("+/position-percent/set")
+        subscribe("+/ip/set")
+        subscribe("+/reset/set")
+        subscribe("+/direction/set")
+        subscribe("+/up-speed/set")
+        subscribe("+/down-speed/set")
+        subscribe("+/slow-speed/set")
+        subscribe("+/up-limit/set")
+        subscribe("+/down-limit/set")
+        subscribe("+/groups/set")
+        (1..16).each do |ip|
+          subscribe("+/ip#{ip}-pulses/set")
+          subscribe("+/ip#{ip}-percent/set")
+        end
+      end
+
+      def publish_motor(addr, node_type)
+        motor = nil
+
+        @mqtt.batch_publish do
+          publish("#{addr}/$name", addr)
+          publish("#{addr}/$type", node_type.to_s)
+          properties = %w{
+            discover
+            label
+            state
+            control
+            jog-ms
+            jog-pulses
+            position-pulses
+            position-percent
+            ip
+            down-limit
+            groups
+            last-direction
+          } + (1..16).map { |ip| ["ip#{ip}-pulses", "ip#{ip}-percent"] }.flatten
+
+          unless node_type == :st50ilt2
+            properties.concat %w{
+              reset
+              last-action-source
+              last-action-cause
+              up-limit
+              direction
+              up-speed
+              down-speed
+              slow-speed
+            }
+          end
+
+          publish("#{addr}/$properties", properties.join(","))
+
+          publish("#{addr}/discover/$name", "Trigger Motor Discovery")
+          publish("#{addr}/discover/$datatype", "enum")
+          publish("#{addr}/discover/$format", "discover")
+          publish("#{addr}/discover/$settable", "true")
+          publish("#{addr}/discover/$retained", "false")
+
+          publish("#{addr}/label/$name", "Node label")
+          publish("#{addr}/label/$datatype", "string")
+          publish("#{addr}/label/$settable", "true")
+
+          publish("#{addr}/state/$name", "Current state of the motor")
+          publish("#{addr}/state/$datatype", "enum")
+          publish("#{addr}/state/$format", Message::PostMotorStatus::STATE.keys.join(','))
+
+          publish("#{addr}/control/$name", "Control motor")
+          publish("#{addr}/control/$datatype", "enum")
+          publish("#{addr}/control/$format", "up,down,stop,wink,next_ip,previous_ip,refresh")
+          publish("#{addr}/control/$settable", "true")
+          publish("#{addr}/control/$retained", "false")
+
+          publish("#{addr}/jog-ms/$name", "Jog motor by ms")
+          publish("#{addr}/jog-ms/$datatype", "integer")
+          publish("#{addr}/jog-ms/$format", "-65535:65535")
+          publish("#{addr}/jog-ms/$unit", "ms")
+          publish("#{addr}/jog-ms/$settable", "true")
+          publish("#{addr}/jog-ms/$retained", "false")
+
+          publish("#{addr}/jog-pulses/$name", "Jog motor by pulses")
+          publish("#{addr}/jog-pulses/$datatype", "integer")
+          publish("#{addr}/jog-pulses/$format", "-65535:65535")
+          publish("#{addr}/jog-pulses/$unit", "pulses")
+          publish("#{addr}/jog-pulses/$settable", "true")
+          publish("#{addr}/jog-pulses/$retained", "false")
+
+          publish("#{addr}/position-percent/$name", "Position (in %)")
+          publish("#{addr}/position-percent/$datatype", "integer")
+          publish("#{addr}/position-percent/$format", "0:100")
+          publish("#{addr}/position-percent/$unit", "%")
+          publish("#{addr}/position-percent/$settable", "true")
+
+          publish("#{addr}/position-pulses/$name", "Position from up limit (in pulses)")
+          publish("#{addr}/position-pulses/$datatype", "integer")
+          publish("#{addr}/position-pulses/$format", "0:65535")
+          publish("#{addr}/position-pulses/$unit", "pulses")
+          publish("#{addr}/position-pulses/$settable", "true")
+
+          publish("#{addr}/ip/$name", "Intermediate Position")
+          publish("#{addr}/ip/$datatype", "integer")
+          publish("#{addr}/ip/$format", "1:16")
+          publish("#{addr}/ip/$settable", "true")
+          publish("#{addr}/ip/$retained", "false") if node_type == :st50ilt2
+
+          publish("#{addr}/down-limit/$name", "Down limit")
+          publish("#{addr}/down-limit/$datatype", "integer")
+          publish("#{addr}/down-limit/$format", "0:65535")
+          publish("#{addr}/down-limit/$unit", "pulses")
+          publish("#{addr}/down-limit/$settable", "true")
+
+          publish("#{addr}/last-direction/$name", "Direction of last motion")
+          publish("#{addr}/last-direction/$datatype", "enum")
+          publish("#{addr}/last-direction/$format", Message::PostMotorStatus::DIRECTION.keys.join(','))
+
+          unless node_type == :st50ilt2
+            publish("#{addr}/reset/$name", "Recall factory settings")
+            publish("#{addr}/reset/$datatype", "enum")
+            publish("#{addr}/reset/$format", Message::SetFactoryDefault::RESET.keys.join(','))
+            publish("#{addr}/reset/$settable", "true")
+            publish("#{addr}/reset/$retained", "false")
+
+            publish("#{addr}/last-action-source/$name", "Source of last action")
+            publish("#{addr}/last-action-source/$datatype", "enum")
+            publish("#{addr}/last-action-source/$format", Message::PostMotorStatus::SOURCE.keys.join(','))
+
+            publish("#{addr}/last-action-cause/$name", "Cause of last action")
+            publish("#{addr}/last-action-cause/$datatype", "enum")
+            publish("#{addr}/last-action-cause/$format", Message::PostMotorStatus::CAUSE.keys.join(','))
+
+            publish("#{addr}/up-limit/$name", "Up limit (always = 0)")
+            publish("#{addr}/up-limit/$datatype", "integer")
+            publish("#{addr}/up-limit/$format", "0:65535")
+            publish("#{addr}/up-limit/$unit", "pulses")
+            publish("#{addr}/up-limit/$settable", "true")
+
+            publish("#{addr}/direction/$name", "Motor rotation direction")
+            publish("#{addr}/direction/$datatype", "enum")
+            publish("#{addr}/direction/$format", "standard,reversed")
+            publish("#{addr}/direction/$settable", "true")
+
+            publish("#{addr}/up-speed/$name", "Up speed")
+            publish("#{addr}/up-speed/$datatype", "integer")
+            publish("#{addr}/up-speed/$format", "6:28")
+            publish("#{addr}/up-speed/$unit", "RPM")
+            publish("#{addr}/up-speed/$settable", "true")
+
+            publish("#{addr}/down-speed/$name", "Down speed, always = Up speed")
+            publish("#{addr}/down-speed/$datatype", "integer")
+            publish("#{addr}/down-speed/$format", "6:28")
+            publish("#{addr}/down-speed/$unit", "RPM")
+            publish("#{addr}/down-speed/$settable", "true")
+
+            publish("#{addr}/slow-speed/$name", "Slow speed")
+            publish("#{addr}/slow-speed/$datatype", "integer")
+            publish("#{addr}/slow-speed/$format", "6:28")
+            publish("#{addr}/slow-speed/$unit", "RPM")
+            publish("#{addr}/slow-speed/$settable", "true")
+          end
+
+          publish("#{addr}/groups/$name", "Group Memberships (comma separated, address must start 0101xx)")
+          publish("#{addr}/groups/$datatype", "string")
+          publish("#{addr}/groups/$settable", "true")
+
+          (1..16).each do |ip|
+            publish("#{addr}/ip#{ip}-pulses/$name", "Intermediate Position #{ip}")
+            publish("#{addr}/ip#{ip}-pulses/$datatype", "integer")
+            publish("#{addr}/ip#{ip}-pulses/$format", "0:65535")
+            publish("#{addr}/ip#{ip}-pulses/$unit", "pulses")
+            publish("#{addr}/ip#{ip}-pulses/$settable", "true")
+
+            publish("#{addr}/ip#{ip}-percent/$name", "Intermediate Position #{ip}")
+            publish("#{addr}/ip#{ip}-percent/$datatype", "integer")
+            publish("#{addr}/ip#{ip}-percent/$format", "0:100")
+            publish("#{addr}/ip#{ip}-percent/$unit", "%")
+            publish("#{addr}/ip#{ip}-percent/$settable", "true")
+          end
+
+          motor = Motor.new(self, addr, node_type)
+          @motors[addr] = motor
+          publish("$nodes", (["FFFFFF"] + @motors.keys.sort + @groups.keys.sort).join(","))
+        end
+
+        sdn_addr = Message.parse_address(addr)
+        @mutex.synchronize do
+          @queues[2].push(MessageAndRetries.new(Message::GetNodeLabel.new(sdn_addr), 5, 2))
+          case node_type
+          when :st30
+            @queues[2].push(MessageAndRetries.new(Message::GetMotorStatus.new(sdn_addr), 5, 2))
+            @queues[2].push(MessageAndRetries.new(Message::GetMotorLimits.new(sdn_addr), 5, 2))
+            @queues[2].push(MessageAndRetries.new(Message::GetMotorDirection.new(sdn_addr), 5, 2))
+            @queues[2].push(MessageAndRetries.new(Message::GetMotorRollingSpeed.new(sdn_addr), 5, 2))
+            (1..16).each { |ip| @queues[2].push(MessageAndRetries.new(Message::GetMotorIP.new(sdn_addr, ip), 5, 2)) }
+          when :st50ilt2
+            @queues[2].push(MessageAndRetries.new(Message::ILT2::GetMotorSettings.new(sdn_addr), 5, 2))
+            @queues[2].push(MessageAndRetries.new(Message::ILT2::GetMotorPosition.new(sdn_addr), 5, 2))
+            (1..16).each { |ip| @queues[2].push(MessageAndRetries.new(Message::ILT2::GetMotorIP.new(sdn_addr, ip), 5, 2)) }
+          end
+          (1..16).each { |g| @queues[2].push(MessageAndRetries.new(Message::GetGroupAddr.new(sdn_addr, g), 5, 2)) }
+
+          @cond.signal
+        end
+
+        motor
+      end
+
+      def touch_group(group_addr)
+        group = @groups[Message.print_address(group_addr).gsub('.', '')]
+        group&.publish(:motors, group.motors_string)
+      end
+
+      def add_group(addr)
+        addr = addr.gsub('.', '')
+        group = @groups[addr]
+        return group if group
+
+        @mqtt.batch_publish do
+          publish("#{addr}/$name", addr)
+          publish("#{addr}/$type", "Shade Group")
+          publish("#{addr}/$properties", "discover,control,jog-ms,jog-pulses,position-pulses,position-percent,ip,reset,state,last-direction,motors")
+
+          publish("#{addr}/discover/$name", "Trigger Motor Discovery")
+          publish("#{addr}/discover/$datatype", "enum")
+          publish("#{addr}/discover/$format", "discover")
+          publish("#{addr}/discover/$settable", "true")
+          publish("#{addr}/discover/$retained", "false")
+
+          publish("#{addr}/control/$name", "Control motors")
+          publish("#{addr}/control/$datatype", "enum")
+          publish("#{addr}/control/$format", "up,down,stop,wink,next_ip,previous_ip,refresh")
+          publish("#{addr}/control/$settable", "true")
+          publish("#{addr}/control/$retained", "false")
+
+          publish("#{addr}/jog-ms/$name", "Jog motors by ms")
+          publish("#{addr}/jog-ms/$datatype", "integer")
+          publish("#{addr}/jog-ms/$format", "-65535:65535")
+          publish("#{addr}/jog-ms/$unit", "ms")
+          publish("#{addr}/jog-ms/$settable", "true")
+          publish("#{addr}/jog-ms/$retained", "false")
+
+          publish("#{addr}/jog-pulses/$name", "Jog motors by pulses")
+          publish("#{addr}/jog-pulses/$datatype", "integer")
+          publish("#{addr}/jog-pulses/$format", "-65535:65535")
+          publish("#{addr}/jog-pulses/$unit", "pulses")
+          publish("#{addr}/jog-pulses/$settable", "true")
+          publish("#{addr}/jog-pulses/$retained", "false")
+
+          publish("#{addr}/position-pulses/$name", "Position from up limit (in pulses)")
+          publish("#{addr}/position-pulses/$datatype", "integer")
+          publish("#{addr}/position-pulses/$format", "0:65535")
+          publish("#{addr}/position-pulses/$unit", "pulses")
+          publish("#{addr}/position-pulses/$settable", "true")
+
+          publish("#{addr}/position-percent/$name", "Position (in %)")
+          publish("#{addr}/position-percent/$datatype", "integer")
+          publish("#{addr}/position-percent/$format", "0:100")
+          publish("#{addr}/position-percent/$unit", "%")
+          publish("#{addr}/position-percent/$settable", "true")
+
+          publish("#{addr}/ip/$name", "Intermediate Position")
+          publish("#{addr}/ip/$datatype", "integer")
+          publish("#{addr}/ip/$format", "1:16")
+          publish("#{addr}/ip/$settable", "true")
+
+          publish("#{addr}/state/$name", "State of the motors")
+          publish("#{addr}/state/$datatype", "enum")
+          publish("#{addr}/state/$format", Message::PostMotorStatus::STATE.keys.join(',')  + ",mixed")
+
+          publish("#{addr}/last-direction/$name", "Direction of last motion")
+          publish("#{addr}/last-direction/$datatype", "enum")
+          publish("#{addr}/last-direction/$format", Message::PostMotorStatus::DIRECTION.keys.join(',')  + ",mixed")
+
+          publish("#{addr}/motors/$name", "Comma separated motor addresses that are members of this group")
+          publish("#{addr}/motors/$datatype", "string")
+
+          group = @groups[addr] = Group.new(self, addr)
+          publish("$nodes", (["FFFFFF"] + @motors.keys.sort + @groups.keys.sort).join(","))
+        end
+        group
+      end
+    end
+  end
+end

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