somfy_sdn 2.1.5 → 2.2.0

data/lib/sdn/cli/mqtt.rb

@@ -1,12 +1,15 @@
-require 'mqtt'
-require 'uri'
-require 'set'
+# frozen_string_literal: true
 
-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'
+require "mqtt"
+require "uri"
+require "set"
+
+require "sdn/cli/mqtt/group"
+require "sdn/cli/mqtt/motor"
+require "sdn/cli/mqtt/p_queue"
+require "sdn/cli/mqtt/read"
+require "sdn/cli/mqtt/write"
+require "sdn/cli/mqtt/subscriptions"
 
 module SDN
   module CLI
@@ -22,7 +25,12 @@ module SDN
 
       attr_reader :motors, :groups
 
-      def initialize(port, mqtt_uri, device_id: "somfy", base_topic: "homie", auto_discover: true)
+      def initialize(sdn,
+                     mqtt_uri,
+                     device_id: "somfy",
+                     base_topic: "homie",
+                     auto_discover: true,
+                     known_motors: [])
         @base_topic = "#{base_topic}/#{device_id}"
         @mqtt = ::MQTT::Client.new(mqtt_uri)
         @mqtt.set_will("#{@base_topic}/$state", "lost", retain: true)
@@ -33,7 +41,7 @@ module SDN
 
         @mutex = Mutex.new
         @cond = ConditionVariable.new
-        @queues = [[], [], []]
+        @queue = PQueue.new
         @response_pending = false
         @broadcast_pending = false
 
@@ -43,11 +51,16 @@ module SDN
         clear_tree(@base_topic)
         publish_basic_attributes
 
-        @sdn = Client.new(port)
+        @sdn = sdn
+
+        known_motors&.each do |addr|
+          addr = Message.parse_address(addr)
+          @queue.push(MessageAndRetries.new(Message::GetMotorPosition.new(addr), 5, 0))
+        end
 
         Thread.abort_on_exception = true
-        read_thread = Thread.new { read }
-        write_thread = Thread.new { write }
+        Thread.new { read }
+        Thread.new { write }
         @mqtt.get { |packet| handle_message(packet.topic, packet.payload) }
       end
 
@@ -59,20 +72,19 @@ module SDN
         @mqtt.subscribe("#{@base_topic}/#{topic}")
       end
 
-      def enqueue(message, queue = 0)
+      def enqueue(message)
         @mutex.synchronize do
-          queue = @queues[queue]
-          unless queue.include?(message)
-            queue.push(message)
-            @cond.signal
-          end
+          break if @queue.include?(message)
+
+          @queue.push(message)
+          @cond.signal
         end
       end
 
       def clear_tree(topic)
         @mqtt.subscribe("#{topic}/#")
         @mqtt.unsubscribe("#{topic}/#", wait_for_ack: true)
-        while !@mqtt.queue_empty?
+        until @mqtt.queue_empty?
           packet = @mqtt.get
           @mqtt.publish(packet.topic, nil, retain: true)
         end
@@ -136,7 +148,7 @@ module SDN
         @mqtt.batch_publish do
           publish("#{addr}/$name", addr)
           publish("#{addr}/$type", node_type.to_s)
-          properties = %w{
+          properties = %w[
             discover
             label
             state
@@ -149,19 +161,17 @@ module SDN
             down-limit
             groups
             last-direction
-          } + (1..16).map { |ip| ["ip#{ip}-pulses", "ip#{ip}-percent"] }.flatten
+          ] + (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
-            }
+            properties.push("reset",
+                            "last-action-source",
+                            "last-action-cause",
+                            "up-limit",
+                            "direction",
+                            "up-speed",
+                            "down-speed",
+                            "slow-speed")
           end
 
           publish("#{addr}/$properties", properties.join(","))
@@ -178,7 +188,7 @@ module SDN
 
           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}/state/$format", Message::PostMotorStatus::STATE.keys.join(","))
 
           publish("#{addr}/control/$name", "Control motor")
           publish("#{addr}/control/$datatype", "enum")
@@ -226,22 +236,22 @@ module SDN
 
           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(','))
+          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/$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-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}/last-action-cause/$format", Message::PostMotorStatus::CAUSE.keys.join(","))
 
             publish("#{addr}/up-limit/$name", "Up limit (always = 0)")
             publish("#{addr}/up-limit/$datatype", "integer")
@@ -298,20 +308,39 @@ module SDN
 
         sdn_addr = Message.parse_address(addr)
         @mutex.synchronize do
-          @queues[2].push(MessageAndRetries.new(Message::GetNodeLabel.new(sdn_addr), 5, 2))
+          # message priorities are:
+          # 0 - control
+          # 1 - follow-up (i.e. get position after control)
+          # 2 - get basic motor info
+          # 3 - get advanced motor info
+          # 4 - get group 1
+          # 5 - get ip 1
+          # 6 - get group 2
+          # 7 - get ip 2
+          # ...
+          # 50 - discover
+
+          # The Group and IP sorting makes it so you quickly get the most commonly used group
+          # and IP addresses, while the almost-never-used ones are pushed to the bottom of the list
+
+          @queue.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 :st30, 0x20 # no idea why 0x20, but that's what I get
+            @queue.push(MessageAndRetries.new(Message::GetMotorStatus.new(sdn_addr), 5, 2))
+            @queue.push(MessageAndRetries.new(Message::GetMotorLimits.new(sdn_addr), 5, 2))
+            @queue.push(MessageAndRetries.new(Message::GetMotorDirection.new(sdn_addr), 5, 3))
+            @queue.push(MessageAndRetries.new(Message::GetMotorRollingSpeed.new(sdn_addr), 5, 3))
+            (1..16).each { |ip| 
+            @queue.push(MessageAndRetries.new(Message::GetMotorIP.new(sdn_addr, ip), 5, 2 * ip + 3)) }
           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)) }
+            @queue.push(MessageAndRetries.new(Message::ILT2::GetMotorSettings.new(sdn_addr), 5, 2))
+            @queue.push(MessageAndRetries.new(Message::ILT2::GetMotorPosition.new(sdn_addr), 5, 2))
+            (1..16).each do |ip|
+              @queue.push(MessageAndRetries.new(Message::ILT2::GetMotorIP.new(sdn_addr, ip), 5, 2 * ip + 3))
+            end
           end
-          (1..16).each { |g| @queues[2].push(MessageAndRetries.new(Message::GetGroupAddr.new(sdn_addr, g), 5, 2)) }
+          (1..16).each { |g| @queue.push(MessageAndRetries.new(Message::GetGroupAddr.new(sdn_addr, g), 5, 2 * g + 2)) }
 
           @cond.signal
         end
@@ -320,19 +349,21 @@ module SDN
       end
 
       def touch_group(group_addr)
-        group = @groups[Message.print_address(group_addr).gsub('.', '')]
+        group = @groups[Message.print_address(group_addr).delete(".")]
         group&.publish(:motors, group.motors_string)
       end
 
       def add_group(addr)
-        addr = addr.gsub('.', '')
+        addr = addr.delete(".")
         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}/$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")
@@ -379,11 +410,11 @@ module SDN
 
           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}/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}/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")

data/lib/sdn/cli/provisioner.rb

@@ -1,12 +1,14 @@
-require 'curses'
+# frozen_string_literal: true
+
+require "curses"
 
 module SDN
   module CLI
     class Provisioner
       attr_reader :win, :sdn, :addr, :ns
 
-      def initialize(port, addr = nil)
-        @sdn = Client.new(port)
+      def initialize(sdn, addr = nil)
+        @sdn = sdn
         @reversed = false
         @pulse_count = 10
 
@@ -24,10 +26,11 @@ module SDN
         message = sdn.ensure(Message::GetNodeLabel.new(addr))
 
         node_type = message.node_type
-        @ns = ns = node_type == :st50ilt2 ? Message::ILT2 : Message
+        @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
+        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!
@@ -52,8 +55,10 @@ module SDN
           Curses.nonl
           Curses.curs_set(0)
           @win = Curses.stdscr
-      
+
           process
+        rescue Interrupt
+          # exitting
         rescue => e
           win.setpos(0, 0)
           win.addstr(e.inspect)
@@ -94,33 +99,44 @@ module SDN
             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))
+              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))
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :jog_up_pulses, @pulse_count))
+            else
+              sdn.ensure(Message::MoveOf.new(addr, :jog_up_pulses, @pulse_count))
+            end
             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))
+            if ilt2?
+              sdn.ensure(Message::ILT2::SetMotorPosition.new(addr, :jog_down_pulses, @pulse_count))
+            else
+              sdn.ensure(Message::MoveOf.new(addr, :jog_down_pulses, @pulse_count))
+            end
             wait_for_stop
-          when 'u'
+          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'
+          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'
+          when "r"
             @reversed = !@reversed
             if ilt2?
               sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @limit, @limit - @pos))
@@ -128,18 +144,24 @@ module SDN
               sdn.ensure(Message::SetMotorDirection.new(addr, @reversed ? :reversed : :standard))
             end
             refresh
-          when 'R'
+          when "R"
             next unless ilt2?
+
             @reversed = !@reversed
             sdn.ensure(Message::ILT2::SetMotorSettings.new(addr, reversed_int, @limit, @pos))
             refresh
-          when '<'
+          when "!"
+            next if ilt2?
+
+            sdn.send(Message::SetFactoryDefault.new(addr))
+            break
+          when "<"
             @pulse_count /= 2 if @pulse_count > 5
             print_help
-          when '>'
+          when ">"
             @pulse_count *= 2
             print_help
-          when 'q'
+          when "q"
             break
           end
         end
@@ -147,27 +169,29 @@ module SDN
 
       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
+        win.addstr(<<~TEXT)
+          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
+        TEXT
 
         if ilt2?
           win.addstr("R    reverse motor (but leave position alone)\n")
+        else
+          win.addstr("!    factory reset\n")
         end
         win.addstr("q    quit\n")
         win.refresh
       end
-      
+
       def wait_for_stop
         win.setpos(13, 0)
         win.addstr("Moving...\n")
@@ -183,7 +207,6 @@ r    reverse motor
           end
 
           sdn.receive(0.1) do |message|
-
             if message.is_a?(ns::PostMotorPosition)
               last_pos = @pos
               @pos = message.position_pulses
@@ -198,7 +221,7 @@ r    reverse motor
               win.addstr("\n")
               win.nodelay = false
               refresh
-              return
+              return # rubocop:disable Lint/NonLocalExitFromIterator
             end
           end
           sleep 0.1