somfy_sdn 2.1.5 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83eab2a162518795d82296d471608e8b9a300d34e6b81897630a06e81456ed40
-  data.tar.gz: d8bfc48d510c2a5b97663326bb893d5abc09fd5a4b1876a70e03a408ad446e15
+  metadata.gz: a00033a8ac556f5b578c6d13b678b54393376c1f0439340dbd4afbd4a2376714
+  data.tar.gz: 1925c30fa53a68f0eb388b0ff277a00a0ae40bf2798a93ba8e9b955139b2c989
 SHA512:
-  metadata.gz: c523da782a69732baf2d114fe412125d0406b96764b9119e97cfea221808c6cff702b6a3f7f8b487afba5f85c919f9a554f707405f15f175682a0072512e9ecd
-  data.tar.gz: 56a628ec9e87aab0667c67ad379194bb67c2f5bd0a26c9995ac5b164f4173c296566b3b749fc5823ec7d1151a2e6083add55eef4fe7bcc521a2f11c0812d29bb
+  metadata.gz: ce9dc75cac82bd65e4fd89908f6e6563761c5171c8dc93ab5b0e40fbe0ce0e0bb1dad7d90ef88470d90a050e7893fb1a35edb589ef2881886bf451d5962a6599
+  data.tar.gz: b82d6d1d60509009c7ea7b7501bd9790ae16f295185cdd5c125e10754e3a96ab9ef9d8956da8d4af554f88390eb4faea2eb4bfb7d0bb7e71248c23e043bc0338

data/exe/somfy_sdn

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "somfy_sdn"
+require "thor"
+
+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"
+  class_option :log, type: :string, desc: "Log to a file"
+
+  desc "monitor PORT", "Monitor traffic on the SDN network at PORT"
+  def monitor(port)
+    sdn = handle_global_options(port)
+    SDN.logger.level = :debug
+
+    loop do
+      sdn.receive do |message|
+        # do nothing
+      end
+    end
+  end
+
+  desc "mqtt PORT MQTT_URI", "Run an MQTT bridge to control the SDN network at PORT"
+  option :"device-id", default: "somfy", desc: "The Homie Device ID"
+  option :"base-topic", default: "homie", desc: "The base Homie topic"
+  option :"auto-discover", type: :boolean, default: true, desc: "Do a discovery at startup"
+  option :address, type: :array, desc: "Specify a known motor address to speed discovery"
+  def mqtt(port, mqtt_uri)
+    sdn = handle_global_options(port)
+
+    require "sdn/cli/mqtt"
+
+    SDN::CLI::MQTT.new(sdn,
+                       mqtt_uri,
+                       device_id: options["device-id"],
+                       base_topic: options["base-topic"],
+                       auto_discover: options["auto-discover"],
+                       known_motors: options["address"])
+  end
+
+  desc "provision PORT [ADDRESS]", "Provision a motor (label and set limits) at PORT"
+  def provision(port, address = nil)
+    sdn = handle_global_options(port)
+
+    require "sdn/cli/provisioner"
+    SDN::CLI::Provisioner.new(sdn, address)
+  end
+
+  desc "simulator PORT [ADDRESS]", "Simulate a motor (for debugging purposes) at PORT"
+  def simulator(port, address = nil)
+    sdn = handle_global_options(port)
+    SDN.logger.level = :debug
+
+    require "sdn/cli/simulator"
+    SDN::CLI::Simulator.new(sdn, address)
+  end
+
+  private
+
+  def handle_global_options(port)
+    SDN.logger = Logger.new(options[:log]) if options[:log]
+    SDN.logger.level = options[:verbose] || options[:trace] ? :debug : :info
+
+    SDN::Client.new(port).tap { |sdn| sdn.trace = options[:trace] }
+  end
+end
+
+SomfySDNCLI.start(ARGV)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SDN
   module CLI
     class MQTT
@@ -6,24 +8,24 @@ module SDN
           members.each { |k| self[k] = :nil }
           super
         end
-    
+
         def publish(attribute, value)
-          if self[attribute] != value
-            bridge.publish("#{addr}/#{attribute.to_s.gsub('_', '-')}", value.to_s)
-            self[attribute] = value
-          end
+          return unless self[attribute] != value
+
+          bridge.publish("#{addr}/#{attribute.to_s.tr("_", "-")}", value.to_s)
+          self[attribute] = value
         end
-    
+
         def printed_addr
           Message.print_address(Message.parse_address(addr))
         end
-    
+
         def motor_objects
-          bridge.motors.select { |addr, motor| motor.groups_string.include?(printed_addr) }.values
+          bridge.motors.select { |_addr, motor| motor.groups_string.include?(printed_addr) }.values
         end
-    
+
         def motors_string
-          motor_objects.map { |m| Message.print_address(Message.parse_address(m.addr)) }.sort.join(',')
+          motor_objects.map { |m| Message.print_address(Message.parse_address(m.addr)) }.sort.join(",")
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SDN
   module CLI
     class MQTT
@@ -58,14 +60,14 @@ module SDN
           @groups = [].fill(nil, 0, 16)
           super
         end
-    
+
         def publish(attribute, value)
-          if self[attribute] != value
-            bridge.publish("#{addr}/#{attribute.to_s.gsub('_', '-')}", value.to_s)
-            self[attribute] = value
-          end
+          return unless self[attribute] != value
+
+          bridge.publish("#{addr}/#{attribute.to_s.tr("_", "-")}", value.to_s)
+          self[attribute] = value
         end
-    
+
         def add_group(index, address)
           group = bridge.add_group(Message.print_address(address)) if address
           old_group = @groups[index - 1]
@@ -74,10 +76,13 @@ module SDN
           publish(:groups, groups_string)
           bridge.touch_group(old_group) if old_group
         end
-    
-        def set_groups(groups)
-          return unless groups =~ /^(?:\h{2}[:.]?\h{2}[:.]?\h{2}(?:,\h{2}[:.]?\h{2}[:.]?\h{2})*)?$/i
-          groups = groups.split(',').sort.uniq.map { |g| Message.parse_address(g) }.select { |g| Message.is_group_address?(g) }
+
+        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)
+
+          groups = groups.split(",").sort.uniq.map do |g|
+                     Message.parse_address(g)
+                   end.select { |g| Message.group_address?(g) }
           groups.fill(nil, groups.length, 16 - groups.length)
           messages = []
           sdn_addr = Message.parse_address(addr)
@@ -89,13 +94,13 @@ module SDN
           end
           messages
         end
-    
+
         def groups_string
-          @groups.compact.map { |g| Message.print_address(g) }.sort.uniq.join(',')
+          @groups.compact.map { |g| Message.print_address(g) }.sort.uniq.join(",")
         end
-    
+
         def group_objects
-          groups_string.split(',').map { |addr| bridge.groups[addr.gsub('.', '')] }
+          groups_string.split(",").map { |addr| bridge.groups[addr.delete(".")] }
         end
       end
     end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SDN
+  module CLI
+    class MQTT
+      class PQueue < Array
+        def push(obj)
+          i = index { |o| o.priority > obj.priority }
+          if i
+            insert(i, obj)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,151 +1,150 @@
+# frozen_string_literal: true
+
 module SDN
   module CLI
     class MQTT
       module Read
         def read
           loop do
-            begin
-              @sdn.receive do |message|
-                @mqtt.batch_publish do
-                  SDN.logger.info "read #{message.inspect}"
-
-                  src = Message.print_address(message.src)
-                  # ignore the UAI Plus and ourselves
-                  if src != '7F.7F.7F' && !Message.is_group_address?(message.src) && !(motor = @motors[src.gsub('.', '')])
-                    SDN.logger.info "found new motor #{src}"
-                    @motors_found = true
-                    motor = publish_motor(src.gsub('.', ''), message.node_type)
-                  end
+            @sdn.receive do |message|
+              @mqtt.batch_publish do
+                src = Message.print_address(message.src)
+                # ignore the UAI Plus and ourselves
+                if src != "7F.7F.7F" && !Message.group_address?(message.src) && !(motor = @motors[src.delete(".")])
+                  SDN.logger.info "Found new motor #{src}"
+                  @motors_found = true
+                  motor = publish_motor(src.delete("."), message.node_type)
+                end
 
-                  follow_ups = []
-                  case message
-                  when Message::PostNodeLabel
-                    if (motor.publish(:label, message.label))
-                      publish("#{motor.addr}/$name", message.label)
-                    end
-                  when Message::PostMotorPosition,
-                    Message::ILT2::PostMotorPosition
-                    if message.is_a?(Message::ILT2::PostMotorPosition)
-                      # keep polling while it's still moving; check prior two positions
-                      if motor.position_pulses == message.position_pulses &&
-                        motor.last_position_pulses == message.position_pulses
-                        motor.publish(:state, :stopped)
-                      else
-                        motor.publish(:state, :running)
-                        if motor.position_pulses && motor.position_pulses != message.position_pulses
-                          motor.publish(:last_direction, motor.position_pulses < message.position_pulses ? :down : :up)
-                        end
-                        follow_ups << Message::ILT2::GetMotorPosition.new(message.src)
-                      end
-                      motor.last_position_pulses = motor.position_pulses
-                      ip = (1..16).find do |i|
-                        # divide by 5 for some leniency
-                        motor["ip#{i}_pulses"].to_i / 5 == message.position_pulses / 5
+                follow_ups = []
+                case message
+                when Message::PostNodeLabel
+                  publish("#{motor.addr}/$name", message.label) if motor.publish(:label, message.label)
+                when Message::PostMotorPosition,
+                  Message::ILT2::PostMotorPosition
+                  if message.is_a?(Message::ILT2::PostMotorPosition)
+                    # keep polling while it's still moving; check prior two positions
+                    if motor.position_pulses == message.position_pulses &&
+                       motor.last_position_pulses == message.position_pulses
+                      motor.publish(:state, :stopped)
+                    else
+                      motor.publish(:state, :running)
+                      if motor.position_pulses && motor.position_pulses != message.position_pulses
+                        motor.publish(:last_direction,
+                                      (motor.position_pulses < message.position_pulses) ? :down : :up)
                       end
-                      motor.publish(:ip, ip)
+                      follow_ups << Message::ILT2::GetMotorPosition.new(message.src)
                     end
-                    motor.publish(:position_percent, message.position_percent)
-                    motor.publish(:position_pulses, message.position_pulses)
-                    motor.publish(:ip, message.ip) if message.respond_to?(:ip)
-                    motor.group_objects.each do |group|
-                      positions_percent = group.motor_objects.map(&:position_percent)
-                      positions_pulses = group.motor_objects.map(&:position_pulses)
-                      ips = group.motor_objects.map(&:ip)
+                    motor.last_position_pulses = motor.position_pulses
+                    ip = (1..16).find do |i|
+                      # divide by 5 for some leniency
+                      motor["ip#{i}_pulses"].to_i / 5 == message.position_pulses / 5
+                    end
+                    motor.publish(:ip, ip)
+                  end
+                  motor.publish(:position_percent, message.position_percent)
+                  motor.publish(:position_pulses, message.position_pulses)
+                  motor.publish(:ip, message.ip) if message.respond_to?(:ip)
+                  motor.group_objects.each do |group|
+                    positions_percent = group.motor_objects.map(&:position_percent)
+                    positions_pulses = group.motor_objects.map(&:position_pulses)
+                    ips = group.motor_objects.map(&:ip)
 
-                      position_percent = nil
-                      # calculate an average, but only if we know a position for
-                      # every shade
-                      if !positions_percent.include?(:nil) && !positions_percent.include?(nil)
-                        position_percent = positions_percent.inject(&:+) / positions_percent.length
-                      end
+                    position_percent = nil
+                    # calculate an average, but only if we know a position for
+                    # every shade
+                    if !positions_percent.include?(:nil) && !positions_percent.include?(nil)
+                      position_percent = positions_percent.sum / positions_percent.length
+                    end
 
-                      position_pulses = nil
-                      if !positions_pulses.include?(:nil) && !positions_pulses.include?(nil)
-                        position_pulses = positions_pulses.inject(&:+) / positions_pulses.length
-                      end
+                    position_pulses = nil
+                    if !positions_pulses.include?(:nil) && !positions_pulses.include?(nil)
+                      position_pulses = positions_pulses.sum / positions_pulses.length
+                    end
 
-                      ip = nil
-                      ip = ips.first if ips.uniq.length == 1
-                      ip = nil if ip == :nil
+                    ip = nil
+                    ip = ips.first if ips.uniq.length == 1
+                    ip = nil if ip == :nil
 
-                      group.publish(:position_percent, position_percent)
-                      group.publish(:position_pulses, position_pulses)
-                      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)
-                    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)
+                    group.publish(:position_percent, position_percent)
+                    group.publish(:position_pulses, position_pulses)
+                    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)
+                  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)
-                    end
-                  when Message::PostMotorLimits
-                    motor.publish(:up_limit, message.up_limit)
-                    motor.publish(:down_limit, message.down_limit)
-                  when Message::ILT2::PostMotorSettings
-                    motor.publish(:down_limit, message.limit)
-                  when Message::PostMotorDirection
-                    motor.publish(:direction, message.direction)
-                  when Message::PostMotorRollingSpeed
-                    motor.publish(:up_speed, message.up_speed)
-                    motor.publish(:down_speed, message.down_speed)
-                    motor.publish(:slow_speed, message.slow_speed)
-                  when Message::PostMotorIP,
-                    Message::ILT2::PostMotorIP
-                    motor.publish(:"ip#{message.ip}_pulses", message.position_pulses)
-                    if message.respond_to?(:position_percent)
-                      motor.publish(:"ip#{message.ip}_percent", message.position_percent) 
-                    elsif motor.down_limit
-                      motor.publish(:"ip#{message.ip}_percent", message.position_pulses.to_f / motor.down_limit * 100) 
-                    end
-                  when Message::PostGroupAddr
-                    motor.add_group(message.group_index, message.group_address)
+                    directions = group.motor_objects.map(&:last_direction).uniq
+                    direction = (directions.length == 1) ? directions.first : "mixed"
+                    group.publish(:last_direction, direction)
+                  end
+                when Message::PostMotorLimits
+                  motor.publish(:up_limit, message.up_limit)
+                  motor.publish(:down_limit, message.down_limit)
+                when Message::ILT2::PostMotorSettings
+                  motor.publish(:down_limit, message.limit)
+                when Message::PostMotorDirection
+                  motor.publish(:direction, message.direction)
+                when Message::PostMotorRollingSpeed
+                  motor.publish(:up_speed, message.up_speed)
+                  motor.publish(:down_speed, message.down_speed)
+                  motor.publish(:slow_speed, message.slow_speed)
+                when Message::PostMotorIP,
+                  Message::ILT2::PostMotorIP
+                  motor.publish(:"ip#{message.ip}_pulses", message.position_pulses)
+                  if message.respond_to?(:position_percent)
+                    motor.publish(:"ip#{message.ip}_percent", message.position_percent)
+                  elsif motor.down_limit
+                    motor.publish(:"ip#{message.ip}_percent", message.position_pulses.to_f / motor.down_limit * 100)
                   end
+                when Message::PostGroupAddr
+                  motor.add_group(message.group_index, message.group_address)
+                end
 
-                  @mutex.synchronize do
-                    prior_message_to_group = Message.is_group_address?(@prior_message&.message&.src) if @prior_message
+                @mutex.synchronize do
+                  prior_message_to_group = Message.group_address?(@prior_message&.message&.src) if @prior_message
 
-                    correct_response = @response_pending && @prior_message&.message&.class&.expected_response?(message)
-                    correct_response = false if !prior_message_to_group && message.src != @prior_message&.message&.dest
-                    correct_response = false if prior_message_to_group && message.dest != @prior_message&.message&.src
+                  correct_response = @response_pending && @prior_message&.message&.class&.expected_response?(message)
+                  correct_response = false if !prior_message_to_group && message.src != @prior_message&.message&.dest
+                  correct_response = false if prior_message_to_group && message.dest != @prior_message&.message&.src
 
-                    if prior_message_to_group && correct_response
-                      @pending_group_motors.delete(Message.print_address(message.src).gsub('.', ''))
-                      correct_response = false unless @pending_group_motors.empty?
-                    end
+                  if prior_message_to_group && correct_response
+                    @pending_group_motors.delete(Message.print_address(message.src).delete("."))
+                    correct_response = false unless @pending_group_motors.empty?
+                  end
 
-                    signal = correct_response || !follow_ups.empty?
-                    @response_pending = @broadcast_pending if correct_response
-                    follow_ups.each do |follow_up|
-                      @queues[1].push(MessageAndRetries.new(follow_up, 5, 1)) unless @queues[1].any? { |mr| mr.message == follow_up }
+                  signal = correct_response || !follow_ups.empty?
+                  @response_pending = @broadcast_pending if correct_response
+                  follow_ups.each do |follow_up|
+                    unless @queue.any? { |mr| mr.message == follow_up }
+                      @queue.push(MessageAndRetries.new(follow_up, 5, 1))
                     end
-                    @cond.signal if signal
                   end
-                rescue EOFError
-                  SDN.logger.fatal "EOF reading"
-                  exit 2
-                rescue MalformedMessage => e
-                  SDN.logger.warn "ignoring malformed message: #{e}" unless e.to_s =~ /issing data/
-                rescue => e
-                  SDN.logger.error "got garbage: #{e}; #{e.backtrace}"
+                  @cond.signal if signal
                 end
+              rescue EOFError
+                SDN.logger.fatal "EOF reading"
+                exit 2
+              rescue MalformedMessage => e
+                SDN.logger.warn "Ignoring malformed message: #{e}" unless e.to_s.include?("issing data")
+              rescue => e
+                SDN.logger.error "Got garbage: #{e}; #{e.backtrace}"
               end
             end
           end