somfy_sdn 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 339d400e53c19eeaa513328963a29c4abedb1b4f046d096a478b4f07576224fb
-  data.tar.gz: 806e109d0934740ceebfc5ea51112b91073b9782d5fbb3267aac49808f98690a
+  metadata.gz: c1f060c34defbdfc40cae2d9e3f34535aa31d44d45bbcbb00ff769fc29cbb01c
+  data.tar.gz: a83d074584f5142609c9b2752fbefbeddb7d5247f7a4a6a2c26fa80d3f679c68
 SHA512:
-  metadata.gz: a2b29a899d358c26a2640e359263785354f9eaff371ec5738d4cb78f58352d6e58fc91c24dca7f4445137eb2739e583cd3901ebda81a161f1d49b223e44617ff
-  data.tar.gz: 5bc0d2fee7de84b8d69a6396f03ae4f4d61248b9c109c08f3e7ba1d3e35bc2d0a93e46178ee5c7963efdf6360da43969c9334e83b70ae453abe392743145a5c7
+  metadata.gz: 39226a05926b458bffb5f91ba69dbcd06d19a1d6daccf98d47c4caf2908e3d991afe5b0ee1917a4dcb0cc4d96fb03056cc9b4f017408666d7c93b32528f10e08
+  data.tar.gz: 2b80671284b192bc6eba54c98bf615e41dfe7990be3d343127f14a5cd8c222b7a45840c52c1de8a208d8b9468bdfd3bafd8acdd3f829198a9c2321ea6485b3b3

data/lib/sdn/message.rb

@@ -5,79 +5,44 @@ module SDN
 
   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 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}"
-        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(' ')}"
+        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[2])
-        src = transform_param(data[3..5])
-        dest = transform_param(data[6..8])
+        reserved = to_number(data[offset + 2])
+        src = transform_param(data.slice(offset + 3, 3))
+        dest = transform_param(data.slice(offset + 6, 3))
         result = message_class.new(reserved: reserved, ack_requested: ack_requested, src: src, dest: dest)
-        result.parse(data[9..-1])
+        result.parse(data.slice(offset + 9, length - 11))
         result.msg = msg if message_class == UnknownMessage
-        result
+        [result, offset + length]
       end
     end
 

data/lib/sdn/mqtt_bridge.rb

@@ -1,5 +1,7 @@
 require 'mqtt'
 require 'serialport'
+require 'socket'
+require 'uri'
 require 'set'
 
 module SDN
@@ -92,24 +94,56 @@ module SDN
   end
 
   class MQTTBridge
-    def initialize(mqtt_uri, serialport, device_id: "somfy", base_topic: "homie")
+    WAIT_TIME = 0.25
+    BROADCAST_WAIT = 5.0
+
+    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
+
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @command_queue = []
+      @request_queue = []
+      @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"
+        @sdn = TCPSocket.new(uri.host, uri.port)
+      else
+        @sdn = SerialPort.open(serialport, "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)
+            unless message
+              begin
+                buffer.concat(@sdn.read_nonblock(1))
+                next
+              rescue IO::WaitReadable
+                wait = buffer.empty? ? nil : WAIT_TIME
+                if IO.select([@sdn], nil, nil, wait).nil?
+                  # timed out; just discard everything
+                  puts "timed out reading; discarding buffer: #{buffer.unpack('H*').first}"
+                  buffer = ""
+                end
+              end
+              next
+            end
+            # discard how much we read
+            buffer = buffer[bytes_read..-1]
+
             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 +152,7 @@ module SDN
             end
 
             puts "read #{message.inspect}"
+            follow_ups = []
             case message
             when SDN::Message::PostNodeLabel
               if (motor.publish(:label, message.label))
@@ -129,10 +164,10 @@ module SDN
               motor.publish(:ip, message.ip)
             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)
@@ -153,6 +188,12 @@ module SDN
               motor.add_group(message.group_index, message.group_address)
             end
 
+            @mutex.synchronize do
+              signal = @response_pending || !follow_ups.empty?
+              @response_pending = @broadcast_pending
+              @request_queue.concat(follow_ups)
+              @cond.signal if signal
+            end
           rescue SDN::MalformedMessage => e
             puts "ignoring malformed message: #{e}" unless e.to_s =~ /issing data/
           rescue => e
@@ -164,13 +205,43 @@ module SDN
       write_thread = Thread.new do
         begin
           loop do
-            message = @write_queue.pop
+            message = 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
+                  else
+                    @cond.wait(@mutex, remaining_wait)
+                  end
+                end
+              else
+                sleep 0.1
+              end
+
+              message = @command_queue.shift
+              unless message
+                message = @request_queue.shift
+                if message
+                  @response_pending = Time.now.to_f + WAIT_TIME
+                  if message.dest == [0xff, 0xff, 0xff]
+                    @broadcast_pending = Time.now.to_f + BROADCAST_WAIT
+                  end    
+                end
+              end
+
+              # spin until there is a message
+              @cond.wait(@mutex) unless message
+            end
+            next unless message
+
             puts "writing #{message.inspect}"
             @sdn.write(message.serialize)
             @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
           end
         rescue => e
           puts "failure writing: #{e}"
@@ -182,7 +253,10 @@ 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)
+          @mutex.synchronize do
+            @request_queue.push(SDN::Message::GetNodeAddr.new)
+            @cond.signal
+          end
         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$}))
           addr = SDN::Message.parse_address(match[:addr])
           property = match[:property]
@@ -255,13 +329,18 @@ 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| @command_queue.push(m) }
+                @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)
+            @mutex.synchronize do
+              @command_queue.push(message)
+              @request_queue.push(follow_up) unless @request_queue.include?(follow_up)
+              @cond.signal
+            end
           end
         end
       end
@@ -275,6 +354,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")
@@ -441,14 +530,17 @@ module SDN
       publish("$nodes", (["discovery"] + @motors.keys.sort + @groups.to_a).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
+        @request_queue.push(SDN::Message::GetNodeLabel.new(sdn_addr))
+        @request_queue.push(SDN::Message::GetMotorStatus.new(sdn_addr))
+        @request_queue.push(SDN::Message::GetMotorLimits.new(sdn_addr))
+        @request_queue.push(SDN::Message::GetMotorDirection.new(sdn_addr))
+        @request_queue.push(SDN::Message::GetMotorRollingSpeed.new(sdn_addr))
+        (1..16).each { |ip| @request_queue.push(SDN::Message::GetMotorIP.new(sdn_addr, ip)) }
+        (0...16).each { |g| @request_queue.push(SDN::Message::GetGroupAddr.new(sdn_addr, g)) }
+
+        @cond.signal
+      end
 
       motor
     end

data/lib/sdn/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: somfy_sdn
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Cody Cutrer