somfy_sdn 1.0.4 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 339d400e53c19eeaa513328963a29c4abedb1b4f046d096a478b4f07576224fb
-  data.tar.gz: 806e109d0934740ceebfc5ea51112b91073b9782d5fbb3267aac49808f98690a
+  metadata.gz: 7b76beaca35ebf0ae0847fc75bf0fcd12c45e395768cca0c711557b167488e3e
+  data.tar.gz: 64dfc392ef651d1afc6e6a94c8c586e1e95e575c0ff9ba12c74f472cbfe88874
 SHA512:
-  metadata.gz: a2b29a899d358c26a2640e359263785354f9eaff371ec5738d4cb78f58352d6e58fc91c24dca7f4445137eb2739e583cd3901ebda81a161f1d49b223e44617ff
-  data.tar.gz: 5bc0d2fee7de84b8d69a6396f03ae4f4d61248b9c109c08f3e7ba1d3e35bc2d0a93e46178ee5c7963efdf6360da43969c9334e83b70ae453abe392743145a5c7
+  metadata.gz: 87a1138187217fb8bf7fe62e00f69e20b742d2527d4f0059b9a2d4ba42012c887947608fdbfad4123400a0968d99d9c257cb361025ecef668786d34b708a0512
+  data.tar.gz: e6ddbe689d8d60d252c24a1291893b05040a638ba3b86ac3a7bc1c28479a9ccdf0485e5914035818c50e1005b076d148263916ae1e7a66e05efdb075786d1d95

data/lib/sdn.rb

@@ -0,0 +1,6 @@
+require 'sdn/message'
+require 'sdn/mqtt_bridge'
+
+module SDN
+  BROADCAST_ADDRESS = [0xff, 0xff, 0xff]
+end

data/lib/sdn/message.rb

@@ -3,81 +3,51 @@ require 'sdn/messages/helpers'
 module SDN
   class MalformedMessage < RuntimeError; end
 
-  class Message  
+  class Message
     class << self
-      def readpartial(io, length, allow_empty: true)
-        data = []
-        while data.length < length
-          begin
-            data.concat(io.read_nonblock(length - data.length).bytes)
-          rescue EOFError
-            break
-          rescue IO::WaitReadable
-            break if allow_empty
-            IO.select([io])
-          end
+      def parse(data)
+        offset = -1
+        msg = length = ack_requested = message_class = nil
+        # we loop here scanning for a valid message
+        loop do
+          offset += 1
+          return [nil, 0] if data.length - offset < 11
+          msg = to_number(data[offset])
+          length = to_number(data[offset + 1])
+          ack_requested = length & 0x80 == 0x80
+          length &= 0x7f
+          # impossible message
+          next if length < 11 || length > 32
+          # don't have enough data for what this message wants;
+          # it could be garbage on the line so keep scanning
+          next if length > data.length - offset
+
+          message_class = constants.find { |c| (const_get(c, false).const_get(:MSG, false) rescue nil) == msg }
+          message_class = const_get(message_class, false) if message_class
+          message_class ||= UnknownMessage
+
+          calculated_sum = checksum(data.slice(offset, length - 2))
+          read_sum = data.slice(offset + length - 2, 2)
+          next unless read_sum == calculated_sum
+
+          break
         end
-        data
-      end
 
-      def parse(io)
-        io = StringIO.new(io) if io.is_a?(String)
-        data = readpartial(io, 2, allow_empty: false)
-        if data.length != 2
-          # don't have enough data yet; buffer it
-          io.ungetbyte(data.first) if data.length == 1
-          raise MalformedMessage, "Could not get message type and length"
-        end
-        msg = to_number(data.first)
-        length = to_number(data.last)
-        ack_requested = length & 0x80 == 0x80
-        length &= 0x7f
-        if length < 11 || length > 32
-          # only skip over one byte to try and re-sync
-          io.ungetbyte(data.last)
-          raise MalformedMessage, "Message has bogus length: #{length}"
-        end
-        data.concat(readpartial(io, length - 4))
-        unless data.length == length - 2
-          data.reverse.each { |byte| io.ungetbyte(byte) }
-          raise MalformedMessage, "Missing data: got #{data.length} expected #{length}"
+        puts "discarding invalid data prior to message #{data[0...offset].map { |b| '%02x' % b }.join(' ')}" unless offset == 0
+        puts "read #{data.slice(offset, length).map { |b| '%02x' % b }.join(' ')}"
+
+        reserved = to_number(data[offset + 2])
+        src = transform_param(data.slice(offset + 3, 3))
+        dest = transform_param(data.slice(offset + 6, 3))
+        begin
+          result = message_class.new(reserved: reserved, ack_requested: ack_requested, src: src, dest: dest)
+          result.parse(data.slice(offset + 9, length - 11))
+          result.msg = msg if message_class == UnknownMessage
+        rescue ArgumentError => e
+          puts "discarding illegal message #{e}"
+          result = nil
         end
-
-        message_class = constants.find { |c| (const_get(c, false).const_get(:MSG, false) rescue nil) == msg }
-        message_class = const_get(message_class, false) if message_class
-        message_class ||= UnknownMessage
-
-        bogus_checksums = [SetNodeLabel::MSG, PostNodeLabel::MSG].include?(msg)
-
-        calculated_sum = checksum(data)
-        read_sum = readpartial(io, 2)
-        if read_sum.length == 0 || (!bogus_checksums && read_sum.length == 1)
-          read_sum.each { |byte| io.ungetbyte(byte) }
-          data.reverse.each { |byte| io.ungetbyte(byte) }
-          raise MalformedMessage, "Missing data: got #{data.length} expected #{length}"
-        end
-
-        # check both the proper checksum, and a truncated checksum
-        unless calculated_sum == read_sum || (bogus_checksums && calculated_sum.last == read_sum.first)
-            raw_message = (data + read_sum).map { |b| '%02x' % b }.join(' ')
-            # skip over single byte to try and re-sync
-            data.shift
-            read_sum.reverse.each { |byte| io.ungetbyte(byte) }
-            data.reverse.each { |byte| io.ungetbyte(byte) }
-            raise MalformedMessage, "Checksum mismatch for #{message_class.name}: #{raw_message}"
-        end
-        # the checksum was truncated; put back the unused byte
-        io.ungetbyte(read_sum.last) if calculated_sum != read_sum && read_sum.length == 2
-
-        puts "read #{(data + read_sum).map { |b| '%02x' % b }.join(' ')}"
-
-        reserved = to_number(data[2])
-        src = transform_param(data[3..5])
-        dest = transform_param(data[6..8])
-        result = message_class.new(reserved: reserved, ack_requested: ack_requested, src: src, dest: dest)
-        result.parse(data[9..-1])
-        result.msg = msg if message_class == UnknownMessage
-        result
+        [result, offset + length]
       end
     end
 
@@ -85,6 +55,7 @@ module SDN
     singleton_class.include Helpers
 
     attr_reader :reserved, :ack_requested, :src, :dest
+    attr_writer :ack_requested
 
     def initialize(reserved: nil, ack_requested: false, src: nil, dest: nil)
       @reserved = reserved || 0x02 # message sent to Sonesse 30
@@ -107,10 +78,13 @@ module SDN
       length |= 0x80 if ack_requested
       result = transform_param(self.class.const_get(:MSG)) + transform_param(length) + result
       result.concat(checksum(result))
-      puts "wrote #{result.map { |b| '%02x' % b }.join(' ')}"
       result.pack("C*")
     end
 
+    def ==(other)
+      self.serialize == other.serialize
+    end
+
     def inspect
       "#<%s @reserved=%02xh, @ack_requested=%s, @src=%s, @dest=%s%s>" % [self.class.name, reserved, ack_requested, print_address(src), print_address(dest), class_inspect]
     end

data/lib/sdn/messages/control.rb

@@ -27,17 +27,17 @@ module SDN
      end
 
      def direction=(value)
-        raise ArgumentError, "direction must be one of :down, :up, or :cancel" unless DIRECTION.keys.include?(value)
+        raise ArgumentError, "direction must be one of :down, :up, or :cancel (#{value})" unless DIRECTION.keys.include?(value)
         @direction = value
      end
 
      def duration=(value)
-        raise ArgumentError, "duration must be in range 0x0a to 0xff" unless value || value >= 0x0a && value <= 0xff
+        raise ArgumentError, "duration must be in range 0x0a to 0xff (#{value})" unless value && value >= 0x0a && value <= 0xff
         @duration = value
      end
 
      def speed=(value)
-        raise ArgumentError, "speed must be one of :up, :down, or :slow" unless SPEED.keys.include?(value)
+        raise ArgumentError, "speed must be one of :up, :down, or :slow (#{value})" unless SPEED.keys.include?(value)
         @speed = speed
       end
 

data/lib/sdn/messages/ilt2/get.rb

@@ -0,0 +1,9 @@
+module SDN
+  class Message
+    module ILT2
+      class GetMotorPosition < SimpleRequest
+        MSG = 0x44
+      end
+    end
+  end
+end

data/lib/sdn/messages/ilt2/post.rb

@@ -0,0 +1,18 @@
+module SDN
+  class Message
+    module ILT2
+      class PostMotorPosition < Message
+        MSG = 0x64
+        PARAMS_LENGTH = 3
+  
+        attr_accessor :position_pulses, :position_percent
+  
+        def parse(params)
+          super
+          self.position_pulses = to_number(params[0..1])
+          self.position_percent = to_number(params[2]).to_f / 255 * 100
+        end
+      end
+    end
+  end
+end

data/lib/sdn/messages/ilt2/set.rb

@@ -0,0 +1,59 @@
+module SDN
+  class Message
+    module ILT2
+      class SetMotorPosition < Message
+        MSG = 0x54
+        PARAMS_LENGTH = 3
+        TARGET_TYPE = {
+          up_limit: 1,
+          down_limit: 2,
+          stop: 3,
+          ip: 4,
+          next_ip_up: 5,
+          next_ip_down: 6,
+          jog_up: 10,
+          jog_down: 11,
+          position_percent: 16,
+        }.freeze
+
+        attr_reader :target_type, :target
+
+        def initialize(dest = nil, target_type = :up_limit, target = 0, **kwargs)
+          kwargs[:dest] ||= dest
+          super(**kwargs)
+          self.target_type = target_type
+          self.target = target
+        end
+
+        def parse(params)
+          super
+          self.target_type = TARGET_TYPE.invert[to_number(params[0])]
+          target = to_number(params[1..2])
+          if target_type == :position_percent
+            target = target.to_f / 255 * 100
+          end
+          self.target = target
+        end
+
+        def target_type=(value)
+          raise ArgumentError, "target_type must be one of :up_limit, :down_limit, :stop, :ip, :next_ip_up, :next_ip_down, :jog_up, :jog_down, or :position_percent" unless TARGET_TYPE.keys.include?(value)
+          @target_type = value
+        end
+
+        def target=(value)
+          if target_type == :position_percent && value
+            @target = [[0, value].max, 100].min
+          else
+            @target = value&. & 0xffff
+          end
+        end
+
+        def params
+          param = target
+          param = (param * 255 / 100).to_i if target_type == :position_percent
+          transform_param(TARGET_TYPE[target_type]) + from_number(param, 2)
+        end
+      end
+    end
+  end
+end

data/lib/sdn/mqtt_bridge.rb

@@ -1,8 +1,36 @@
 require 'mqtt'
-require 'serialport'
+require 'uri'
 require 'set'
 
 module SDN
+  MessageAndRetries = Struct.new(:message, :remaining_retries, :priority)
+
+  Group = Struct.new(:bridge, :addr, :positionpercent, :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}", 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| SDN::Message.print_address(SDN::Message.parse_address(m.addr)) }.sort.join(',')
+    end
+  end
+
   Motor = Struct.new(:bridge,
                      :addr,
                      :label,
@@ -52,64 +80,110 @@ module SDN
                      :ip16pulses,
                      :ip16percent,
                      :groups) 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}", value.to_s)
-         self[attribute] = value
-       end
-     end
-
-     def add_group(index, address)
-       bridge.add_group(SDN::Message.print_address(address)) if address
-       @groups[index] = address
-       publish(:groups, groups_string)
-     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| SDN::Message.parse_address(g) }
-       groups.fill(nil, groups.length, 16 - groups.length)
-       messages = []
-       sdn_addr = SDN::Message.parse_address(addr)
-       groups.each_with_index do |g, i|
-         if @groups[i] != g
-           messages << SDN::Message::SetGroupAddr.new(sdn_addr, i, g)
-           messages << SDN::Message::GetGroupAddr.new(sdn_addr, i)
-         end
-       end
-       messages
-     end
-
-     def groups_string
-       @groups.compact.map { |g| SDN::Message.print_address(g) }.sort.uniq.join(',')
-     end
+    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}", value.to_s)
+        self[attribute] = value
+      end
+    end
+
+    def add_group(index, address)
+      group = bridge.add_group(SDN::Message.print_address(address)) if address
+      @groups[index] = address
+      group&.publish(:motors, group.motors_string)
+      publish(:groups, groups_string)
+    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| SDN::Message.parse_address(g) }.select { |g| SDN::Message.is_group_address?(g) }
+      groups.fill(nil, groups.length, 16 - groups.length)
+      messages = []
+      sdn_addr = SDN::Message.parse_address(addr)
+      groups.each_with_index do |g, i|
+        if @groups[i] != g
+          messages << SDN::Message::SetGroupAddr.new(sdn_addr, i, g).tap { |m| m.ack_requested = true }
+          messages << SDN::Message::GetGroupAddr.new(sdn_addr, i)
+        end
+      end
+      messages
+    end
+
+    def groups_string
+      @groups.compact.map { |g| SDN::Message.print_address(g) }.sort.uniq.join(',')
+    end
+
+    def group_objects
+      groups_string.split(',').map { |addr| bridge.groups[addr.gsub('.', '')] }
+    end
   end
 
   class MQTTBridge
-    def initialize(mqtt_uri, serialport, device_id: "somfy", base_topic: "homie")
+    WAIT_TIME = 0.25
+    BROADCAST_WAIT = 5.0
+
+    attr_reader :motors, :groups
+
+    def initialize(mqtt_uri, port, device_id: "somfy", base_topic: "homie")
       @base_topic = "#{base_topic}/#{device_id}"
       @mqtt = MQTT::Client.new(mqtt_uri)
       @mqtt.set_will("#{@base_topic}/$state", "lost", true)
       @mqtt.connect
+
       @motors = {}
-      @groups = Set.new
-      @write_queue = Queue.new
+      @groups = {}
+
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @queues = [[], [], []]
+      @response_pending = false
+      @broadcast_pending = false
 
       publish_basic_attributes
 
-      @sdn = SerialPort.open(serialport, "baud" => 4800, "parity" => SerialPort::ODD)
+      uri = URI.parse(port)
+      if uri.scheme == "tcp"
+        require 'socket'
+        @sdn = TCPSocket.new(uri.host, uri.port)
+      elsif uri.scheme == "telnet" || uri.scheme == "rfc2217"
+        require 'net/telnet/rfc2217'
+        @sdn = Net::Telnet::RFC2217.new('Host' => uri.host,
+         'Port' => uri.port || 23,
+         'baud' => 4800,
+         'parity' => Net::Telnet::RFC2217::ODD)
+      else
+        require 'serialport'
+        @sdn = SerialPort.open(port, "baud" => 4800, "parity" => SerialPort::ODD)
+      end
 
       read_thread = Thread.new do
+        buffer = ""
         loop do
           begin
-            message = SDN::Message.parse(@sdn)
-            next unless message
+            message, bytes_read = SDN::Message.parse(buffer.bytes)
+            # discard how much we read
+            buffer = buffer[bytes_read..-1]
+            unless message
+              begin
+                buffer.concat(@sdn.read_nonblock(64 * 1024))
+                next
+              rescue IO::WaitReadable
+                wait = buffer.empty? ? nil : WAIT_TIME
+                if @sdn.wait_readable(wait).nil?
+                  # timed out; just discard everything
+                  puts "timed out reading; discarding buffer: #{buffer.unpack('H*').first}"
+                  buffer = ""
+                end
+              end
+              next
+            end
+
             src = SDN::Message.print_address(message.src)
             # ignore the UAI Plus and ourselves
             if src != '7F.7F.7F' && !SDN::Message::is_group_address?(message.src) && !(motor = @motors[src.gsub('.', '')])
@@ -118,6 +192,7 @@ module SDN
             end
 
             puts "read #{message.inspect}"
+            follow_ups = []
             case message
             when SDN::Message::PostNodeLabel
               if (motor.publish(:label, message.label))
@@ -127,16 +202,32 @@ module SDN
               motor.publish(:positionpercent, message.position_percent)
               motor.publish(:positionpulses, message.position_pulses)
               motor.publish(:ip, message.ip)
+              motor.group_objects.each do |group|
+                positions = group.motor_objects.map(&:positionpercent)
+                position = nil
+                # calculate an average, but only if we know a position for
+                # every shade
+                if !positions.include?(:nil) && !positions.include?(nil)
+                  position = positions.inject(&:+) / positions.length
+                end
+
+                group.publish(:positionpercent, position)
+              end
             when SDN::Message::PostMotorStatus
               if message.state == :running || motor.state == :running
-                @write_queue.push(SDN::Message::GetMotorStatus.new(message.src))
+                follow_ups << SDN::Message::GetMotorStatus.new(message.src)
               end
               # this will do one more position request after it stopped
-              @write_queue.push(SDN::Message::GetMotorPosition.new(message.src))
+              follow_ups << SDN::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)
+              end
             when SDN::Message::PostMotorLimits
               motor.publish(:uplimit, message.up_limit)
               motor.publish(:downlimit, message.down_limit)
@@ -147,12 +238,23 @@ module SDN
               motor.publish(:downspeed, message.down_speed)
               motor.publish(:slowspeed, message.slow_speed)
             when SDN::Message::PostMotorIP
-              motor.publish(:"ip#{message.ip}pulses", message.position_pulses) 
+              motor.publish(:"ip#{message.ip}pulses", message.position_pulses)
               motor.publish(:"ip#{message.ip}percent", message.position_percent)
             when SDN::Message::PostGroupAddr
               motor.add_group(message.group_index, message.group_address)
             end
 
+            @mutex.synchronize do
+              signal = @response_pending || !follow_ups.empty?
+              @response_pending = @broadcast_pending
+              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
+            puts "EOF reading"
+            exit 2
           rescue SDN::MalformedMessage => e
             puts "ignoring malformed message: #{e}" unless e.to_s =~ /issing data/
           rescue => e
@@ -164,13 +266,57 @@ module SDN
       write_thread = Thread.new do
         begin
           loop do
-            message = @write_queue.pop
+            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
+                    puts "timed out waiting on response"
+                    @response_pending = nil
+                    @broadcast_pending = nil
+                    if @prior_message&.remaining_retries != 0
+                      puts "retrying #{@prior_message.remaining_retries} more times ..."
+                      @queues[@prior_message.priority].push(@prior_message)
+                      @prior_message = nil
+                    end
+                  else
+                    @cond.wait(@mutex, remaining_wait)
+                  end
+                end
+              else
+                # minimum time between messages
+                sleep 0.1
+              end
+
+              @queues.find { |q| message_and_retries = q.shift }
+              if message_and_retries
+                if message_and_retries.message.ack_requested || message_and_retries.class.name =~ /^SDN::Message::Get/
+                  @response_pending = Time.now.to_f + WAIT_TIME
+                  if message_and_retries.message.dest == BROADCAST_ADDRESS || SDN::Message::is_group_address?(message_and_retries.message.src) && message_and_retries.message.is_a?(SDN::Message::GetNodeAddr)
+                    @broadcast_pending = Time.now.to_f + BROADCAST_WAIT
+                  end
+                end
+              end
+
+              # wait until there is a message
+              @cond.wait(@mutex) unless message_and_retries
+            end
+            next unless message_and_retries
+
+            message = message_and_retries.message
             puts "writing #{message.inspect}"
-            @sdn.write(message.serialize)
+            serialized = message.serialize
+            @sdn.write(serialized)
             @sdn.flush
-            # give more response time to a discovery message
-            sleep 5 if (message.is_a?(SDN::Message::GetNodeAddr) && message.dest == [0xff, 0xff, 0xff])
-            sleep 0.1
+            puts "wrote #{serialized.unpack("C*").map { |b| '%02x' % b }.join(' ')}"
+            if @response_pending
+              message_and_retries.remaining_retries -= 1
+              @prior_message = message_and_retries
+            else
+              @prior_message = nil
+            end
           end
         rescue => e
           puts "failure writing: #{e}"
@@ -182,8 +328,11 @@ module SDN
         puts "got #{value.inspect} at #{topic}"
         if topic == "#{@base_topic}/discovery/discover/set" && value == "true"
           # trigger discovery
-          @write_queue.push(SDN::Message::GetNodeAddr.new)
-        elsif (match = topic.match(%r{^#{Regexp.escape(@base_topic)}/(?<addr>\h{6})/(?<property>label|down|up|stop|positionpulses|positionpercent|ip|wink|reset|(?<speed_type>upspeed|downspeed|slowspeed)|uplimit|downlimit|direction|ip(?<ip>\d+)(?<ip_type>pulses|percent)|groups)/set$}))
+          @mutex.synchronize do
+            @queues[2].push(MessageAndRetries.new(SDN::Message::GetNodeAddr.new, 1, 2))
+            @cond.signal
+          end
+        elsif (match = topic.match(%r{^#{Regexp.escape(@base_topic)}/(?<addr>\h{6})/(?<property>discover|label|down|up|stop|positionpulses|positionpercent|ip|wink|reset|(?<speed_type>upspeed|downspeed|slowspeed)|uplimit|downlimit|direction|ip(?<ip>\d+)(?<ip_type>pulses|percent)|groups)/set$}))
           addr = SDN::Message.parse_address(match[:addr])
           property = match[:property]
           # not homie compliant; allows linking the positionpercent property
@@ -192,10 +341,15 @@ module SDN
             property = value.downcase
             value = "true"
           end
-          motor = @motors[SDN::Message.print_address(addr).gsub('.', '')]
+          mqtt_addr = SDN::Message.print_address(addr).gsub('.', '')
+          motor = @motors[mqtt_addr]
           is_group = SDN::Message.is_group_address?(addr)
+          group = @groups[mqtt_addr]
           follow_up = SDN::Message::GetMotorStatus.new(addr)
           message = case property
+            when 'discover'
+              follow_up = nil
+              SDN::Message::GetNodeAddr.new(addr) if value == "true"
             when 'label'
               follow_up = SDN::Message::GetNodeLabel.new(addr)
               SDN::Message::SetNodeLabel.new(addr, value) unless is_group
@@ -255,13 +409,19 @@ module SDN
               next if is_group
               next unless motor
               messages = motor.set_groups(value)
-              messages.each { |m| @write_queue.push(m) }
+              @mutex.synchronize do
+                messages.each { |m| @queues[0].push(MessageAndRetries.new(m, 5, 0)) }
+                @cond.signal
+              end
               nil
           end
           if message
-            @write_queue.push(message)
-            next if follow_up.is_a?(SDN::Message::GetMotorStatus) && motor&.state == :running
-            @write_queue.push(follow_up)
+            message.ack_requested = true if motor && message.class.name !~ /^SDN::Message::Get/
+            @mutex.synchronize do
+              @queues[0].push(MessageAndRetries.new(message, message.ack_requested ? 5 : 1, 0))
+              @queues[1].push(MessageAndRetries.new(follow_up, 5, 1)) unless @queues[1].any? { |mr| mr.message == follow_up }
+              @cond.signal
+            end
           end
         end
       end
@@ -275,6 +435,16 @@ module SDN
       @mqtt.subscribe("#{@base_topic}/#{topic}")
     end
 
+    def enqueue(message, queue = :command)
+      @mutex.synchronize do
+        queue = instance_variable_get(:"#{@queue}_queue")
+        unless queue.include?(message)
+          queue.push(message)
+          @cond.signal
+        end
+      end
+    end
+
     def publish_basic_attributes
       publish("$homie", "v4.0.0")
       publish("$name", "Somfy SDN Network")
@@ -290,7 +460,7 @@ module SDN
       publish("discovery/discover/$settable", "true")
       publish("discovery/discover/$retained", "false")
 
-      subscribe("discovery/discover/set")
+      subscribe("+/discover/set")
       subscribe("+/label/set")
       subscribe("+/down/set")
       subscribe("+/up/set")
@@ -318,7 +488,12 @@ module SDN
     def publish_motor(addr)
       publish("#{addr}/$name", addr)
       publish("#{addr}/$type", "Sonesse 30 Motor")
-      publish("#{addr}/$properties", "label,down,up,stop,positionpulses,positionpercent,ip,wink,reset,state,last_direction,last_action_source,last_action_cause,uplimit,downlimit,direction,upspeed,downspeed,slowspeed,#{(1..16).map { |ip| "ip#{ip}pulses,ip#{ip}percent" }.join(',')},groups")
+      publish("#{addr}/$properties", "discover,label,down,up,stop,positionpulses,positionpercent,ip,wink,reset,state,last_direction,last_action_source,last_action_cause,uplimit,downlimit,direction,upspeed,downspeed,slowspeed,#{(1..16).map { |ip| "ip#{ip}pulses,ip#{ip}percent" }.join(',')},groups")
+
+      publish("#{addr}/discover/$name", "Trigger Motor Discovery")
+      publish("#{addr}/discover/$datatype", "boolean")
+      publish("#{addr}/discover/$settable", "true")
+      publish("#{addr}/discover/$retained", "false")
 
       publish("#{addr}/label/$name", "Node label")
       publish("#{addr}/label/$datatype", "string")
@@ -438,28 +613,37 @@ module SDN
 
       motor = Motor.new(self, addr)
       @motors[addr] = motor
-      publish("$nodes", (["discovery"] + @motors.keys.sort + @groups.to_a).join(","))
+      publish("$nodes", (["discovery"] + @motors.keys.sort + @groups.keys.sort).join(","))
 
       sdn_addr = SDN::Message.parse_address(addr)
-      # these messages are often corrupt; just don't bother for now.
-      #@write_queue.push(SDN::Message::GetNodeLabel.new(sdn_addr))
-      @write_queue.push(SDN::Message::GetMotorStatus.new(sdn_addr))
-      @write_queue.push(SDN::Message::GetMotorLimits.new(sdn_addr))
-      @write_queue.push(SDN::Message::GetMotorDirection.new(sdn_addr))
-      @write_queue.push(SDN::Message::GetMotorRollingSpeed.new(sdn_addr))
-      (1..16).each { |ip| @write_queue.push(SDN::Message::GetMotorIP.new(sdn_addr, ip)) }
-      (0...16).each { |g| @write_queue.push(SDN::Message::GetGroupAddr.new(sdn_addr, g)) }
+      @mutex.synchronize do
+        @queues[2].push(MessageAndRetries.new(SDN::Message::GetNodeLabel.new(sdn_addr), 5, 2))
+        @queues[2].push(MessageAndRetries.new(SDN::Message::GetMotorStatus.new(sdn_addr), 5, 2))
+        @queues[2].push(MessageAndRetries.new(SDN::Message::GetMotorLimits.new(sdn_addr), 5, 2))
+        @queues[2].push(MessageAndRetries.new(SDN::Message::GetMotorDirection.new(sdn_addr), 5, 2))
+        @queues[2].push(MessageAndRetries.new(SDN::Message::GetMotorRollingSpeed.new(sdn_addr), 5, 2))
+        (1..16).each { |ip| @queues[2].push(MessageAndRetries.new(SDN::Message::GetMotorIP.new(sdn_addr, ip), 5, 2)) }
+        (0...16).each { |g| @queues[2].push(MessageAndRetries.new(SDN::Message::GetGroupAddr.new(sdn_addr, g), 5, 2)) }
+
+        @cond.signal
+      end
 
       motor
     end
 
     def add_group(addr)
       addr = addr.gsub('.', '')
-      return if @groups.include?(addr)
+      group = @groups[addr]
+      return group if group
 
       publish("#{addr}/$name", addr)
       publish("#{addr}/$type", "Shade Group")
-      publish("#{addr}/$properties", "down,up,stop,positionpulses,positionpercent,ip,wink,reset")
+      publish("#{addr}/$properties", "discover,down,up,stop,positionpulses,positionpercent,ip,wink,reset,state,motors")
+
+      publish("#{addr}/discover/$name", "Trigger Motor Discovery")
+      publish("#{addr}/discover/$datatype", "boolean")
+      publish("#{addr}/discover/$settable", "true")
+      publish("#{addr}/discover/$retained", "false")
 
       publish("#{addr}/down/$name", "Move in down direction")
       publish("#{addr}/down/$datatype", "boolean")
@@ -474,7 +658,7 @@ module SDN
       publish("#{addr}/stop/$name", "Cancel adjustments")
       publish("#{addr}/stop/$datatype", "boolean")
       publish("#{addr}/stop/$settable", "true")
-      publish("#{addr}/stop/$retained", "false")      
+      publish("#{addr}/stop/$retained", "false")
 
       publish("#{addr}/positionpulses/$name", "Position from up limit (in pulses)")
       publish("#{addr}/positionpulses/$datatype", "integer")
@@ -498,8 +682,16 @@ module SDN
       publish("#{addr}/wink/$settable", "true")
       publish("#{addr}/wink/$retained", "false")
 
-      @groups << addr
-      publish("$nodes", (["discovery"] + @motors.keys.sort + @groups.to_a).join(","))
+      publish("#{addr}/state/$name", "State of the motors; only set if all motors are in the same state")
+      publish("#{addr}/state/$datatype", "enum")
+      publish("#{addr}/state/$format", SDN::Message::PostMotorStatus::STATE.keys.join(','))
+
+      publish("#{addr}/motors/$name", "Motors that are members of this group")
+      publish("#{addr}/motors/$datatype", "string")
+
+      group = @groups[addr] = Group.new(self, addr)
+      publish("$nodes", (["discovery"] + @motors.keys.sort + @groups.keys.sort).join(","))
+      group
     end
   end
 end

data/lib/sdn/version.rb

@@ -1,3 +1,3 @@
 module SDN
-  VERSION = '1.0.4'
+  VERSION = '1.0.9'
 end

data/lib/somfy_sdn.rb

@@ -1,2 +1 @@
-require 'sdn/message'
-require 'sdn/mqtt_bridge'
+require 'sdn'

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: somfy_sdn
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.9
 platform: ruby
 authors:
 - Cody Cutrer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-13 00:00:00.000000000 Z
+date: 2020-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: serialport
+  name: mqtt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
-  name: mqtt
+  name: net-telnet-rfc2217
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -74,10 +88,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/sdn_mqtt_bridge
+- lib/sdn.rb
 - lib/sdn/message.rb
 - lib/sdn/messages/control.rb
 - lib/sdn/messages/get.rb
 - lib/sdn/messages/helpers.rb
+- lib/sdn/messages/ilt2/get.rb
+- lib/sdn/messages/ilt2/post.rb
+- lib/sdn/messages/ilt2/set.rb
 - lib/sdn/messages/post.rb
 - lib/sdn/messages/set.rb
 - lib/sdn/mqtt_bridge.rb