somfy_sdn 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e1e1adfb127498d09f9df75ebcbe479aef58ee8412f4a9cb977d8b11e45b119
-  data.tar.gz: 140db72e519d25a12028f901f0287ee6a41fd7c6071f25df406fd115616883ab
+  metadata.gz: b0cde44546a65fc3e056bd24f4b2306d87669f219bbb8f759b13d6b5f26dcfdf
+  data.tar.gz: 85da8daf249310449f80a7fb1d0bb6579c009efc9f65ab121deb0106be122ddf
 SHA512:
-  metadata.gz: e42ed8ef8086f84247e70743e73f3d4f1dccc2a83e541d4f88bb2bb7d719f85ff16c95375de660e4398adc305517e76e43d766a9bf84de8f9247e32d1bc2fceb
-  data.tar.gz: 879ab6fc00ba20c2c0b0bc1946ab2760702c791fc458955b65cc2c27db4687ccb8d95d112aedce0953f10e2d7ba88f7e54d20998e89bbd3519c0230971a79b7c
+  metadata.gz: f4665bc4b50b981ee51f89e1be7a14b943209a639179e59b6175991e7bf94612bf1c9bf603f98603a4234f7c99f4cd81cb25ae1ba96542641555d9d01a152a33
+  data.tar.gz: e7fb11e6d77febe8718d732e36f32fce86628fd31169e266b61f0784b063402dba5231494c66b45e04346a7c37191fdaf0eb57c4c7329369ac111f8dca6cf512

data/exe/somfy_sdn

@@ -5,6 +5,7 @@ require "somfy_sdn"
 require "thor"
 require "uri"
 
+# @!visibility private
 class SomfySDNCLI < Thor
   class_option :verbose, type: :boolean, default: false, desc: "Log protocol messages"
   class_option :trace, type: :boolean, default: false, desc: "Log protocol bytes"

data/lib/sdn/cli/mqtt/group.rb

@@ -3,6 +3,7 @@
 module SDN
   module CLI
     class MQTT
+      # In-memory state container for a discovered group and its aggregated MQTT attributes.
       Group = Struct.new(:bridge,
                          :addr,
                          :position_percent,
@@ -17,6 +18,7 @@ module SDN
           super
         end
 
+        # @!visibility private
         def publish(attribute, value)
           return unless self[attribute] != value
 
@@ -24,14 +26,23 @@ module SDN
           self[attribute] = value
         end
 
+        # @return [String]
         def printed_addr
           Message.print_address(Message.parse_address(addr))
         end
 
+        # @!attribute [r] motor_objects
+        #
+        # @return [<SDN::CLI::MQTT::Motor>]
         def motor_objects
           bridge.motors.select { |_addr, motor| motor.groups_string.include?(printed_addr) }.values
         end
 
+        # @!attribute [r] motors_string
+        #
+        # Returns the current group membership as a comma-separated motor address list.
+        #
+        # @return [String]
         def motors_string
           motor_objects.map { |m| Message.print_address(Message.parse_address(m.addr)) }.sort.join(",")
         end

data/lib/sdn/cli/mqtt/motor.rb

@@ -3,6 +3,7 @@
 module SDN
   module CLI
     class MQTT
+      # In-memory state container for a discovered motor and its published MQTT attributes.
       Motor = Struct.new(:bridge,
                          :addr,
                          :node_type,
@@ -55,13 +56,17 @@ module SDN
                          :ip16_percent,
                          :groups,
                          :last_action,
-                         :last_position_pulses) do
+                         :last_position_pulses,
+                         :last_action_retries) do
         def initialize(*)
           members.each { |k| self[k] = :nil }
           @groups = [].fill(nil, 0, 16)
           super
+          self.last_action = Message::Stop
+          self.last_action_retries = 0
         end
 
+        # @!visibility private
         def publish(attribute, value)
           return unless self[attribute] != value
 
@@ -69,6 +74,12 @@ module SDN
           self[attribute] = value
         end
 
+        # Updates a group slot and refreshes derived group membership state.
+        #
+        # @param index [Integer] group slot number
+        # @param address [(Integer, Integer, Integer), nil] group address
+        #
+        # @return [void]
         def add_group(index, address)
           group = bridge.add_group(Message.print_address(address)) if address
           old_group = @groups[index - 1]
@@ -78,6 +89,11 @@ module SDN
           bridge.touch_group(old_group) if old_group
         end
 
+        # Builds the SDN writes needed to reconcile group membership with a comma-separated list.
+        #
+        # @param groups [String] comma-separated group addresses
+        #
+        # @return [<SDN::Message>]
         def set_groups(groups) # rubocop:disable Naming/AccessorMethodName
           return unless /^(?:\h{2}[:.]?\h{2}[:.]?\h{2}(?:,\h{2}[:.]?\h{2}[:.]?\h{2})*)?$/i.match?(groups)
 
@@ -96,10 +112,18 @@ module SDN
           messages
         end
 
+        # @!attribute [r] groups_string
+        #
+        # Returns the current group membership list as a normalized string.
+        #
+        # @return [String]
         def groups_string
           @groups.compact.map { |g| Message.print_address(g) }.sort.uniq.join(",")
         end
 
+        # @!attribute [r] group_objects
+        #
+        # @return [<SDN::CLI::MQTT::Group>]
         def group_objects
           groups_string.split(",").map { |addr| bridge.groups[addr.delete(".")] }
         end

data/lib/sdn/cli/mqtt/p_queue.rb

@@ -3,7 +3,13 @@
 module SDN
   module CLI
     class MQTT
+      # Priority queue used to order outbound SDN messages by importance.
       class PQueue < Array
+        # Inserts a queued item ahead of lower-priority entries.
+        #
+        # @param obj [Object] queued item responding to `priority`
+        #
+        # @return [Array] the queue itself
         def push(obj)
           i = index { |o| o.priority > obj.priority }
           if i

data/lib/sdn/cli/mqtt/read.rb

@@ -3,7 +3,11 @@
 module SDN
   module CLI
     class MQTT
+      # Reader loop that translates SDN responses into MQTT state updates.
       module Read
+        # Continuously consumes SDN messages and republishes state to MQTT.
+        #
+        # @return [void]
         def read
           loop do
             @sdn.receive do |message|
@@ -71,53 +75,7 @@ module SDN
                     group.publish(:ip, ip)
                   end
                 when Message::PostMotorStatus
-                  if message.state == :running || motor.state == :running ||
-                     # if it's explicitly stopped, but we didn't ask it to, it's probably
-                     # changing directions so keep querying
-                     (message.state == :stopped &&
-                       message.last_action_cause == :explicit_command &&
-                       !(motor.last_action == Message::Stop || motor.last_action.nil?))
-                    follow_ups << Message::GetMotorStatus.new(message.src)
-                  end
-                  # this will do one more position request after it stopped
-                  follow_ups << Message::GetMotorPosition.new(message.src)
-                  motor.publish(:state, message.state)
-                  motor.publish(:last_direction, message.last_direction)
-                  hass_state = if message.state == :running
-                                 (message.last_direction == :down) ? :closing : :opening
-                               elsif motor.position_percent&.zero?
-                                 :open
-                               elsif motor.position_percent == 100
-                                 :closed
-                               else
-                                 :stopped
-                               end
-                  motor.publish(:hass_state, hass_state)
-                  motor.publish(:last_action_source, message.last_action_source)
-                  motor.publish(:last_action_cause, message.last_action_cause)
-                  motor.group_objects.each do |group|
-                    states = group.motor_objects.map(&:state).uniq
-                    state = (states.length == 1) ? states.first : "mixed"
-                    group.publish(:state, state)
-
-                    directions = group.motor_objects.map(&:last_direction).uniq
-                    direction = (directions.length == 1) ? directions.first : "mixed"
-                    group.publish(:last_direction, direction)
-
-                    positions = group.motor_objects.map(&:position_percent).uniq
-                    position = (positions.length == 1) ? positions.first : 50
-
-                    hass_state = if state == :running
-                                   (direction == :down) ? :closing : :opening
-                                 elsif position.zero?
-                                   :open
-                                 elsif position == 100
-                                   :closed
-                                 else
-                                   :stopped
-                                 end
-                    group.publish(:hass_state, hass_state)
-                  end
+                  handle_post_motor_status(message, motor, follow_ups)
                 when Message::PostMotorLimits
                   motor.publish(:up_limit, message.up_limit)
                   motor.publish(:down_limit, message.down_limit)
@@ -173,6 +131,47 @@ module SDN
             end
           end
         end
+
+        private
+
+        def handle_post_motor_status(message, motor, follow_ups)
+          if message.state == :running || motor.state == :running ||
+             # if it's explicitly stopped, but we didn't ask it to, it's probably
+             # changing directions so keep querying
+             (message.state == :stopped &&
+               message.last_action_cause == :explicit_command &&
+               motor.last_action != Message::Stop && motor.last_action_retries.positive?)
+            if message.state == :stopped
+              SDN.logger.debug("Re-querying motor status for #{motor.addr} #{motor.last_action_retries} " \
+                               "more time(s) even though stopped")
+              motor.last_action_retries -= 1
+            end
+            follow_ups << Message::GetMotorStatus.new(message.src)
+          end
+          # this will do one more position request after it stopped
+          follow_ups << Message::GetMotorPosition.new(message.src)
+          motor.publish(:state, message.state)
+          motor.publish(:last_direction, message.last_direction)
+          motor.publish(:hass_state, motor_hass_state(message.state,
+                                                      message.last_direction,
+                                                      motor.position_percent))
+          motor.publish(:last_action_source, message.last_action_source)
+          motor.publish(:last_action_cause, message.last_action_cause)
+          motor.group_objects.each do |group|
+            states = group.motor_objects.map(&:state).uniq
+            state = (states.length == 1) ? states.first : "mixed"
+            group.publish(:state, state)
+
+            directions = group.motor_objects.map(&:last_direction).uniq
+            direction = (directions.length == 1) ? directions.first : "mixed"
+            group.publish(:last_direction, direction)
+
+            positions = group.motor_objects.map(&:position_percent).uniq
+            position = (positions.length == 1) ? positions.first : 50
+
+            group.publish(:hass_state, motor_hass_state(state, direction, position))
+          end
+        end
       end
     end
   end

data/lib/sdn/cli/mqtt/subscriptions.rb

@@ -3,7 +3,14 @@
 module SDN
   module CLI
     class MQTT
+      # MQTT subscription handlers that translate inbound command messages into SDN commands.
       module Subscriptions
+        # Converts an MQTT command message into one or more queued SDN messages.
+        #
+        # @param topic [String] absolute MQTT topic
+        # @param value [String] MQTT payload
+        #
+        # @return [void]
         def handle_message(topic, value)
           SDN.logger.info "Got #{value.inspect} at #{topic}"
           unless (match = topic.match(%r{^#{Regexp.escape(@base_topic)}/
@@ -181,6 +188,7 @@ module SDN
                        Message::Wink,
                        Message::Stop].include?(message.class)
             motor.last_action = message.class
+            motor.last_action_retries = 3
           end
 
           return unless message

data/lib/sdn/cli/mqtt/write.rb

@@ -3,7 +3,11 @@
 module SDN
   module CLI
     class MQTT
+      # Writer loop that drains the outbound queue and manages retries and follow-up timing.
       module Write
+        # Continuously drains the prioritized queue and transmits SDN messages.
+        #
+        # @return [void]
         def write
           last_write_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -11,34 +15,38 @@ module SDN
             message_and_retries = nil
             @mutex.synchronize do
               # got woken up early by another command getting queued; spin
-              if @response_pending
-                while @response_pending
-                  remaining_wait = @response_pending - Time.now.to_f
-                  if remaining_wait.negative?
-                    SDN.logger.debug "Timed out waiting on response"
-                    @response_pending = nil
-                    @broadcast_pending = nil
-                    if @prior_message && @prior_message&.remaining_retries != 0
-                      SDN.logger.debug "Retrying #{@prior_message.remaining_retries} more times ..."
-                      if Message.group_address?(@prior_message.message.src) && !@pending_group_motors.empty?
-                        SDN.logger.debug "Re-targetting group message to individual motors"
-                        @pending_group_motors.each do |addr|
-                          new_message = @prior_message.message.dup
-                          new_message.src = [0, 0, 1]
-                          new_message.dest = Message.parse_address(addr)
-                          @queue.push(MessageAndRetries.new(new_message,
-                                                            @prior_message.remaining_retries,
-                                                            @prior_message.priority))
-                        end
-                        @pending_group_motors = []
-                      else
-                        @queue.push(@prior_message)
+              while @response_pending
+                remaining_wait = @response_pending - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                if remaining_wait.negative?
+                  if @prior_message
+                    SDN.logger.info "Timed out waiting on response to #{@prior_message.message.inspect}; " \
+                                    "retries left: #{@prior_message.remaining_retries}"
+                  else
+                    SDN.logger.info "Timed out waiting on response"
+                  end
+                  @response_pending = nil
+                  @broadcast_pending = nil
+                  if @prior_message
+                    if @prior_message.remaining_retries.zero?
+                      handle_timeout_fallback(@prior_message.message)
+                    elsif Message.group_address?(@prior_message.message.src) && !@pending_group_motors.empty?
+                      SDN.logger.debug "Re-targetting group message to individual motors"
+                      @pending_group_motors.each do |addr|
+                        new_message = @prior_message.message.dup
+                        new_message.src = [0, 0, 1]
+                        new_message.dest = Message.parse_address(addr)
+                        @queue.push(MessageAndRetries.new(new_message,
+                                                          @prior_message.remaining_retries,
+                                                          @prior_message.priority))
                       end
-                      @prior_message = nil
+                      @pending_group_motors = []
+                    else
+                      @queue.push(@prior_message)
                     end
-                  else
-                    @cond.wait(@mutex, remaining_wait)
+                    @prior_message = nil
                   end
+                else
+                  @cond.wait(@mutex, remaining_wait)
                 end
               end
 
@@ -46,7 +54,7 @@ module SDN
               if message_and_retries && (
                 message_and_retries.message.ack_requested ||
                 message_and_retries.message.class.name =~ /^SDN::Message::Get/)
-                @response_pending = Time.now.to_f + WAIT_TIME
+                @response_pending = Process.clock_gettime(Process::CLOCK_MONOTONIC) + WAIT_TIME
                 @pending_group_motors = if Message.group_address?(message_and_retries.message.src)
                                           group_addr = Message.print_address(message_and_retries.message.src).delete(
                                             "."
@@ -59,7 +67,7 @@ module SDN
                 if message_and_retries.message.dest == BROADCAST_ADDRESS || (
                   Message.group_address?(message_and_retries.message.src) &&
                   message_and_retries.message.is_a?(Message::GetNodeAddr))
-                  @broadcast_pending = Time.now.to_f + BROADCAST_WAIT
+                  @broadcast_pending = Process.clock_gettime(Process::CLOCK_MONOTONIC) + BROADCAST_WAIT
                 end
               end
 
@@ -92,6 +100,38 @@ module SDN
           SDN.logger.fatal "Failure writing: #{e}: #{e.backtrace}"
           exit 1
         end
+
+        private
+
+        def handle_timeout_fallback(message)
+          case message
+          when Message::GetMotorStatus
+            handle_get_motor_status_timeout(message)
+          when Message::GetMotorPosition, Message::ILT2::GetMotorPosition
+            handle_get_motor_position_timeout(message)
+          end
+        end
+
+        def handle_get_motor_status_timeout(message)
+          addr = Message.print_address(message.dest).delete(".")
+          motor = @motors[addr]
+          return unless motor&.state == :running
+
+          motor.publish(:state, :stopped)
+          motor.publish(:hass_state, motor_hass_state(:stopped, motor.last_direction, motor.position_percent))
+          motor.publish(:last_action_source, :bridge)
+          motor.publish(:last_action_cause, :timeout)
+        end
+
+        def handle_get_motor_position_timeout(message)
+          addr = Message.print_address(message.dest).delete(".")
+          motor = @motors[addr]
+          return unless motor
+
+          motor.publish(:position_pulses, nil)
+          motor.publish(:position_percent, nil)
+          motor.publish(:ip, nil)
+        end
       end
     end
   end