somfy_sdn 1.0.12 → 2.0.0

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

@@ -0,0 +1,31 @@
+module SDN
+  module CLI
+    class MQTT
+      Group = Struct.new(:bridge, :addr, :position_percent, :position_pulses, :ip, :last_direction, :state, :motors) do
+        def initialize(*)
+          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
+        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
+        end
+    
+        def motors_string
+          motor_objects.map { |m| Message.print_address(Message.parse_address(m.addr)) }.sort.join(',')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+module SDN
+  module CLI
+    class MQTT
+      Motor = Struct.new(:bridge,
+                         :addr,
+                         :node_type,
+                         :label,
+                         :position_pulses,
+                         :position_percent,
+                         :ip,
+                         :state,
+                         :last_direction,
+                         :last_action_source,
+                         :last_action_cause,
+                         :up_limit,
+                         :down_limit,
+                         :direction,
+                         :up_speed,
+                         :down_speed,
+                         :slow_speed,
+                         :ip1_pulses,
+                         :ip1_percent,
+                         :ip2_pulses,
+                         :ip2_percent,
+                         :ip3_pulses,
+                         :ip3_percent,
+                         :ip4_pulses,
+                         :ip4_percent,
+                         :ip5_pulses,
+                         :ip5_percent,
+                         :ip6_pulses,
+                         :ip6_percent,
+                         :ip7_pulses,
+                         :ip7_percent,
+                         :ip8_pulses,
+                         :ip8_percent,
+                         :ip9_pulses,
+                         :ip9_percent,
+                         :ip10_pulses,
+                         :ip10_percent,
+                         :ip11_pulses,
+                         :ip11_percent,
+                         :ip12_pulses,
+                         :ip12_percent,
+                         :ip13_pulses,
+                         :ip13_percent,
+                         :ip14_pulses,
+                         :ip14_percent,
+                         :ip15_pulses,
+                         :ip15_percent,
+                         :ip16_pulses,
+                         :ip16_percent,
+                         :groups,
+                         :last_action,
+                         :last_position_pulses) do
+        def initialize(*)
+          members.each { |k| self[k] = :nil }
+          @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
+        end
+    
+        def add_group(index, address)
+          group = bridge.add_group(Message.print_address(address)) if address
+          old_group = @groups[index - 1]
+          @groups[index - 1] = address
+          group&.publish(:motors, group.motors_string)
+          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) }
+          groups.fill(nil, groups.length, 16 - groups.length)
+          messages = []
+          sdn_addr = Message.parse_address(addr)
+          groups.each_with_index do |g, i|
+            if @groups[i] != g
+              messages << Message::SetGroupAddr.new(sdn_addr, i + 1, g).tap { |m| m.ack_requested = true }
+              messages << Message::GetGroupAddr.new(sdn_addr, i + 1)
+            end
+          end
+          messages
+        end
+    
+        def groups_string
+          @groups.compact.map { |g| Message.print_address(g) }.sort.uniq.join(',')
+        end
+    
+        def group_objects
+          groups_string.split(',').map { |addr| bridge.groups[addr.gsub('.', '')] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+module SDN
+  module CLI
+    class MQTT
+      module Read
+        def read
+          loop do
+            begin
+              @sdn.receive do |message|
+                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
+
+                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
+                    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_pulses = nil
+                    if !positions_pulses.include?(:nil) && !positions_pulses.include?(nil)
+                      position_pulses = positions_pulses.inject(&:+) / positions_pulses.length
+                    end
+
+                    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)
+
+                    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
+
+                  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
+
+                  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 }
+                  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}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module SDN
+  module CLI
+    class MQTT
+      module Subscriptions
+        def handle_message(topic, value)
+          SDN.logger.info "got #{value.inspect} at #{topic}"
+          if (match = topic.match(%r{^#{Regexp.escape(@base_topic)}/(?<addr>\h{6})/(?<property>discover|label|control|jog-(?<jog_type>pulses|ms)|position-pulses|position-percent|ip|reset|(?<speed_type>up-speed|down-speed|slow-speed)|up-limit|down-limit|direction|ip(?<ip>\d+)-(?<ip_type>pulses|percent)|groups)/set$}))
+            addr = Message.parse_address(match[:addr])
+            property = match[:property]
+            # not homie compliant; allows linking the position-percent property
+            # directly to an OpenHAB rollershutter channel
+            if property == 'position-percent' && value =~ /^(?:UP|DOWN|STOP)$/i
+              property = "control"
+              value = value.downcase
+            end
+            mqtt_addr = Message.print_address(addr).gsub('.', '')
+            motor = @motors[mqtt_addr]
+            is_group = Message.is_group_address?(addr)
+            group = @groups[mqtt_addr]
+            follow_up = motor&.node_type == :st50ilt2 ? Message::ILT2::GetMotorPosition.new(addr) :
+              Message::GetMotorStatus.new(addr)
+            ns = motor&.node_type == :st50ilt2 ? Message::ILT2 : Message
+
+            message = case property
+              when 'discover'
+                follow_up = nil
+                if value == "discover"
+                  # discovery is low priority, and longer timeout
+                  enqueue(MessageAndRetries.new(Message::GetNodeAddr.new(addr), 1, 2), 2)
+                end
+                nil
+              when 'label'
+                follow_up = Message::GetNodeLabel.new(addr)
+                ns::SetNodeLabel.new(addr, value) unless is_group
+              when 'control'
+                case value
+                when 'up', 'down'
+                  (motor&.node_type == :st50ilt2 ? ns::SetMotorPosition : Message::MoveTo).
+                    new(addr, "#{value}_limit".to_sym)
+                when 'stop'
+                  motor&.node_type == :st50ilt2 ? ns::SetMotorPosition.new(addr, :stop) : Message::Stop.new(addr)
+                when 'next_ip'
+                  motor&.node_type == :st50ilt2 ? ns::SetMotorPosition.new(addr, :next_ip_down) :
+                    Message::MoveOf.new(addr, :next_ip)
+                when 'previous_ip'
+                  motor&.node_type == :st50ilt2 ? ns::SetMotorPosition.new(addr, :next_ip_up) :
+                    Message::MoveOf.new(addr, :previous_ip)
+                when 'wink'
+                  Message::Wink.new(addr)
+                when 'refresh'
+                  follow_up = nil
+                  (motor&.node_type == :st50ilt2 ? ns::GetMotorPosition : Message::GetMotorStatus).
+                    new(addr)
+                end
+              when /jog-(?:pulses|ms)/
+                value = value.to_i
+                (motor&.node_type == :st50ilt2 ? ns::SetMotorPosition : Message::MoveOf).
+                  new(addr, "jog_#{value < 0 ? :up : :down }_#{match[:jog_type]}".to_sym, value.abs)
+              when 'reset'
+                return unless Message::SetFactoryDefault::RESET.keys.include?(value.to_sym)
+                Message::SetFactoryDefault.new(addr, value.to_sym)
+              when 'position-pulses', 'position-percent', 'ip'
+                if value == 'REFRESH'
+                  follow_up = nil
+                  (motor&.node_type == :st50ilt2 ? ns::GetMotorPosition : Message::GetMotorStatus).
+                    new(addr)
+                else
+                  (motor&.node_type == :st50ilt2 ? ns::SetMotorPosition : Message::MoveTo).
+                    new(addr, property.sub('position-', 'position_').to_sym, value.to_i)
+                end
+              when 'direction'
+                return if is_group
+                follow_up = Message::GetMotorDirection.new(addr)
+                return unless %w{standard reversed}.include?(value)
+                Message::SetMotorDirection.new(addr, value.to_sym)
+              when 'up-limit', 'down-limit'
+                return if is_group
+                if %w{delete current_position jog_ms jog_pulses}.include?(value)
+                  type = value.to_sym
+                  value = 10
+                else
+                  type = :specified_position
+                end
+                target = property == 'up-limit' ? :up : :down
+                follow_up = Message::GetMotorLimits.new(addr)
+                Message::SetMotorLimits.new(addr, type, target, value.to_i)
+              when /^ip\d-(?:pulses|percent)$/
+                return if is_group
+                ip = match[:ip].to_i
+                return unless (1..16).include?(ip)
+                follow_up = ns::GetMotorIP.new(addr, ip)
+
+                if motor&.node_type == :st50ilt2
+                  value = if value == 'delete'
+                    nil
+                  elsif value == 'current_position'
+                    motor.position_pulses
+                  elsif match[:ip_type] == 'pulses'
+                    value.to_i
+                  else
+                    value.to_f / motor.down_limit * 100
+                  end
+                  ns::SetMotorIP.new(addr, ip, value)
+                else
+                  type = if value == 'delete'
+                    :delete
+                  elsif value == 'current_position'
+                    :current_position
+                  elsif match[:ip_type] == 'pulses'
+                    :position_pulses
+                  else
+                    :position_percent
+                  end
+                  Message::SetMotorIP.new(addr, type, ip, value.to_i)
+                end
+              when 'up-speed', 'down-speed', 'slow-speed'
+                return if is_group
+                return unless motor
+                follow_up = Message::GetMotorRollingSpeed.new(addr)
+                message = Message::SetMotorRollingSpeed.new(addr,
+                  up_speed: motor.up_speed,
+                  down_speed: motor.down_speed,
+                  slow_speed: motor.slow_speed)
+                message.send(:"#{property.sub('-', '_')}=", value.to_i)
+                message
+              when 'groups'
+                return if is_group
+                return unless motor
+                messages = motor.set_groups(value)
+                @mutex.synchronize do
+                  messages.each { |m| @queues[0].push(MessageAndRetries.new(m, 5, 0)) }
+                  @cond.signal
+                end
+                nil
+            end
+
+            if motor
+              motor.last_action = message.class if [Message::MoveTo, Message::Move, Message::Wink, Message::Stop].include?(message.class)
+            end
+
+            if message
+              message.ack_requested = true if message.class.name !~ /^SDN::Message::Get/
+              @mutex.synchronize do
+                @queues[0].push(MessageAndRetries.new(message, 5, 0))
+                if follow_up
+                  @queues[1].push(MessageAndRetries.new(follow_up, 5, 1)) unless @queues[1].any? { |mr| mr.message == follow_up }
+                end
+                @cond.signal
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module SDN
+  module CLI
+    class MQTT
+      module Write
+        def write
+          last_write_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          loop do
+            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 < 0
+                    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.is_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)
+                          @queues[@prior_message.priority].push(MessageAndRetries.new(new_message, @prior_message.remaining_retries, @prior_message.priority))
+                        end
+                        @pending_group_motors = []
+                      else
+                        @queues[@prior_message.priority].push(@prior_message)
+                      end
+                      @prior_message = nil
+                    end
+                  else
+                    @cond.wait(@mutex, remaining_wait)
+                  end
+                end
+              end
+
+              @queues.find { |q| message_and_retries = q.shift }
+              if message_and_retries
+                if message_and_retries.message.ack_requested || message_and_retries.message.class.name =~ /^SDN::Message::Get/
+                  @response_pending = Time.now.to_f + WAIT_TIME
+                  @pending_group_motors = if Message.is_group_address?(message_and_retries.message.src)
+                    group_addr = Message.print_address(message_and_retries.message.src).gsub('.', '')
+                    @groups[group_addr]&.motor_objects&.map(&:addr) || []
+                  else
+                    []
+                  end
+                    
+                  if message_and_retries.message.dest == BROADCAST_ADDRESS || Message.is_group_address?(message_and_retries.message.src) && message_and_retries.message.is_a?(Message::GetNodeAddr)
+                    @broadcast_pending = Time.now.to_f + BROADCAST_WAIT
+                  end
+                end
+              end
+
+              # wait until there is a message
+              if @response_pending
+                message_and_retries.remaining_retries -= 1
+                @prior_message = message_and_retries  
+              elsif message_and_retries
+                @prior_message = nil  
+              else
+                if @auto_discover && @motors_found
+                  # nothing pending to write, and motors found on the last iteration;
+                  # look for more motors
+                  message_and_retries = MessageAndRetries.new(Message::GetNodeAddr.new, 1, 2)
+                  @motors_found = false
+                else
+                  @cond.wait(@mutex)
+                end
+              end
+            end
+            next unless message_and_retries
+
+            message = message_and_retries.message
+            SDN.logger.info "writing #{message.inspect}"
+            # minimum time between messages
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            sleep_time = 0.1 - (now - last_write_at)
+            sleep(sleep_time) if sleep_time > 0
+            @sdn.send(message)
+            last_write_at = now
+          end
+        rescue => e
+          SDN.logger.fatal "failure writing: #{e}: #{e.backtrace}"
+          exit 1
+        end
+      end
+    end
+  end
+end