somfy_sdn 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43e93c1bd91289025342d8fb230e4fc961a04001eb8a607a0114cf40c92459f3
+  data.tar.gz: 1f29a53d8e8f697b0b6933439d42d154e439992567abdcf6f216aa5d3e7dfed3
+SHA512:
+  metadata.gz: 13a0bb6280317801ea68d5a87e1fc2105f01fb6f44423cd4e7a9f553c04d2fb8a5d2009ae663b9f46889e7955c3eec6200330ba51abbd0005b4512b00b4041ca
+  data.tar.gz: e6bb95d108574b3ef836630721a22bf514a93d17470c6f25ecced7519c3cf646c6129121413e7f263d044b41a275f86f8ebc3050e83866b6b2e278ebc0df491e

data/bin/sdn_mqtt_bridge

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'somfy_sdn'
+
+SDN::MQTTBridge.new(ARGV[0], ARGV[1])

data/lib/sdn/message.rb

@@ -0,0 +1,179 @@
+require 'sdn/messages/helpers'
+
+module SDN
+    class MalformedMessage < RuntimeError; end
+  
+    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
+          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(' ')}"
+  
+          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
+        end
+      end
+  
+      include Helpers
+      singleton_class.include Helpers
+  
+      attr_reader :reserved, :ack_requested, :src, :dest
+  
+      def initialize(reserved: nil, ack_requested: false, src: nil, dest: nil)
+        @reserved = reserved || 0x02 # message sent to Sonesse 30
+        @ack_requested = ack_requested
+        if src.nil? && is_group_address?(dest)
+          src = dest
+          dest = nil
+        end
+        @src = src || [0, 0, 1]
+        @dest = dest || [0, 0, 0]
+      end
+  
+      def parse(params)
+        raise MalformedMessage, "unrecognized params for #{self.class.name}: #{params.map { |b| '%02x' % b }}" if self.class.const_defined?(:PARAMS_LENGTH) && params.length != self.class.const_get(:PARAMS_LENGTH)
+      end
+  
+      def serialize
+        result = transform_param(reserved) + transform_param(src) + transform_param(dest) + params
+        length = result.length + 4
+        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 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
+  
+      def class_inspect
+        ivars = instance_variables - [:@reserved, :@ack_requested, :@src, :@dest]
+        return if ivars.empty?
+        ivars.map { |iv| ", #{iv}=#{instance_variable_get(iv).inspect}" }.join
+      end
+  
+      protected
+  
+      def params; []; end
+
+      public
+  
+      class SimpleRequest < Message
+        PARAMS_LENGTH = 0
+  
+        def initialize(dest = nil, **kwargs)
+          kwargs[:dest] ||= dest
+          super(**kwargs)
+        end
+      end
+
+      class Nack < Message
+        MSG = 0x6f
+        PARAMS_LENGTH = 1
+        VALUES = { data_error: 0x01, unknown_message: 0x10, node_is_locked: 0x20, wrong_position: 0x21, limits_not_set: 0x22, ip_not_set: 0x23, out_of_range: 0x24, busy: 0xff }
+  
+        # presumed
+        attr_accessor :error_code
+  
+        def parse(params)
+          super
+          error_code = to_number(params[0])
+          self.error_code = VALUES[error_code] || error_code
+        end
+      end
+  
+      class Ack < Message
+        MSG = 0x7f
+        PARAMS_LENGTH = 0
+      end
+
+      # messages after this point were decoded from UAI+ communication and may be named wrong
+      class UnknownMessage < Message
+        attr_accessor :msg, :params
+  
+        alias parse params=
+  
+        def class_inspect
+          result = ", @msg=%02xh" % msg
+          return result if params.empty?
+  
+          result << ", @params=#{params.map { |b| "%02x" % b }.join(' ')}"
+        end
+      end
+    end
+  end
+end
+
+require 'sdn/messages/control'
+require 'sdn/messages/get'
+require 'sdn/messages/post'
+require 'sdn/messages/set'

data/lib/sdn/messages/control.rb

@@ -0,0 +1,154 @@
+module SDN
+  class Message
+    # Move in momentary mode
+    class Move < Message
+      MSG = 0x01
+      PARAMS_LENGTH = 3
+      DIRECTION = { down: 0x00, up: 0x01, cancel: 0x02 }.freeze
+      SPEED = { up: 0x00, down: 0x01, slow: 0x02 }.freeze
+
+      attr_reader :direction, :duration, :speed
+
+      def initialize(dest = nil, direction = :cancel, duration: nil, speed: :up, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.direction = direction
+        self.duration = duration
+        self.speed = speed
+     end
+
+     def parse(params)
+       super
+       self.direction = DIRECTION.invert[to_number(params[0])]
+       duration = to_number(params[1])
+       duration = nil if duration == 0
+       self.duration = duration
+       self.speed = SPEED.invert[to_number(params[3])]
+     end
+
+     def direction=(value)
+        raise ArgumentError, "direction must be one of :down, :up, or :cancel" 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
+        @duration = value
+     end
+
+     def speed=(value)
+        raise ArgumentError, "speed must be one of :up, :down, or :slow" unless SPEED.keys.include?(value)
+        @speed = speed
+      end
+
+      def params
+        transform_param(DIRECTION[direction]) +
+          transform_param(duration || 0) +
+          transform_param(SPEED[speed])
+      end
+    end
+
+    # Stop movement
+    class Stop < Message
+      MSG = 0x02
+      PARAMS_LENGTH = 1
+
+      def initialize(dest = nil, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+      end
+
+      def params
+        transform_param(0)
+      end
+    end
+
+    # Move to absolute position
+    class MoveTo < Message
+      MSG = 0x03
+      PARAMS_LENGTH = 4
+      TARGET_TYPE = { down_limit: 0x00, up_limit: 0x01, ip: 0x02, position_pulses: 0x03, position_percent: 0x04 }.freeze
+      SPEED = { up: 0x00, down: 0x01, slow: 0x02 }.freeze
+
+      attr_reader :target_type, :target, :speed
+
+      def initialize(dest= nil, target_type = :down_limit, target = nil, speed = :up, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.target_type = target_type
+        self.target = target
+        self.speed = speed
+      end
+
+      def parse(params)
+        super
+        self.target_type = TARGET_TYPE.invert[to_number(params[0])]
+        self.target = to_number(params[1..2], nillable: true)
+        self.speed = SPEED.invert[to_number(params[3])]
+      end
+
+      def target_type=(value)
+        raise ArgumentError, "target_type must be one of :down_limit, :up_limit, :ip, :position_pulses, or :position_percent" unless TARGET_TYPE.keys.include?(value)
+        @target_type = value
+      end
+
+      def target=(value)
+        value &= 0xffff if value
+        @target = value
+      end
+
+      def speed=(value)
+        raise ArgumentError, "speed must be one of :up, :down, or :slow" unless SPEED.keys.include?(value)
+        @speed = value
+      end
+
+      def params
+        transform_param(TARGET_TYPE[target_type]) + from_number(target || 0xffff, 2) + transform_param(SPEED[speed])
+      end
+    end
+
+    # Move relative to current position
+    class MoveOf < Message
+      MSG = 0x04
+      PARAMS_LENGTH = 4
+      TARGET_TYPE = { next_ip: 0x00, previous_ip: 0x01, jog_down_pulses: 0x02, jog_up_pulses: 0x03, jog_down_ms: 0x04, jog_up_ms: 0x05 }
+
+      attr_reader :target_type, :target
+
+      def initialize(dest = nil, target_type = nil, target = nil, **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], nillable: true)
+        target *= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
+        self.target = target
+      end
+
+      def target_type=(value)
+        raise ArgumentError, "target_type must be one of :next_ip, :previous_ip, :jog_down_pulses, :jog_up_pulses, :jog_down_ms, :jog_up_ms" unless value.nil? || TARGET_TYPE.keys.include?(value)
+        @target_type = value
+      end
+
+      def target=(value)
+        value &= 0xffff if value
+        @target = value
+      end
+
+      def params
+        param = target || 0xffff
+        param /= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
+        transform_param(TARGET_TYPE[target_type]) + from_number(param, 2) + transform_param(0)
+      end
+    end
+
+    class Wink < SimpleRequest
+      MSG = 0x05
+    end
+  end
+end

data/lib/sdn/messages/get.rb

@@ -0,0 +1,99 @@
+module SDN
+  class Message
+    class GetMotorPosition < SimpleRequest
+      MSG = 0x0c
+    end
+
+    class GetMotorStatus < SimpleRequest
+      MSG = 0x0e
+    end
+
+    class GetMotorLimits < SimpleRequest
+      MSG = 0x21
+    end
+
+    class GetMotorDirection < SimpleRequest
+      MSG = 0x22
+    end
+
+    class GetMotorRollingSpeed < SimpleRequest
+      MSG = 0x23
+    end
+
+    class GetMotorIP < Message
+      MSG = 0x25
+      PARAMS_LENGTH = 1
+
+      attr_reader :ip
+
+      def initialize(dest = nil, ip = nil, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.ip = ip
+      end
+
+      def parse(params)
+        super
+        self.ip = to_number(params[0], nillable: true)
+      end
+
+      def ip=(value)
+        raise ArgumentError, "invalid IP #{ip} (should be 1-16)" unless ip.nil? || (1..16).include?(ip)
+        @ip = value
+      end
+
+      def params
+        transform_param(@ip || 0xff)
+      end
+    end
+
+    class GetGroupAddr < Message
+      MSG = 0x41
+      PARAMS_LENGTH = 1
+
+      attr_reader :group_index
+
+      def initialize(dest = nil, group_index = 0, **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+        self.group_index = group_index
+      end
+
+      def parse(params)
+        super
+        self.group_index = to_number(params[0])
+      end
+
+      def group_index=(value)
+        raise ArgumentError, "group_index is out of range" unless (0...16).include?(value)
+        @group_index = value
+      end
+
+      def params
+        transform_param(group_index)
+      end
+    end
+
+    class GetNodeLabel < SimpleRequest
+      MSG = 0x45
+    end
+
+    class GetNodeAddr < Message
+      MSG = 0x40
+      PARAMS_LENGTH = 0
+
+      def initialize(dest = [0xff, 0xff, 0xff], **kwargs)
+        kwargs[:dest] ||= dest
+        super(**kwargs)
+      end
+    end
+
+    class GetNodeSerialNumber < SimpleRequest
+      MSG = 0x4c
+    end
+
+    class GetNodeStackVersion < SimpleRequest
+      MSG = 0x70
+    end
+  end
+end

data/lib/sdn/messages/helpers.rb

@@ -0,0 +1,51 @@
+module SDN
+  class Message
+    module Helpers
+      def parse_address(addr_string)
+        addr_string.match(/^(\h{2})[:.]?(\h{2})[:.]?(\h{2})$/).captures.map { |byte| byte.to_i(16) }
+      end
+
+      def print_address(addr_bytes)
+        "%02X.%02X.%02X" % addr_bytes
+      end
+
+      def is_group_address?(addr_bytes)
+        addr_bytes[0..1] == [1, 1]
+      end
+
+      def transform_param(param)
+        Array(param).reverse.map { |byte| 0xff - byte }
+      end
+
+      def to_number(param, nillable: false)
+        result = Array(param).reverse.inject(0) { |sum, byte| (sum << 8) + 0xff - byte }
+        result = nil if nillable && result == (1 << (8 * Array(param).length)) - 1
+        result
+      end
+
+      def from_number(number, bytes)
+        bytes.times.inject([]) do |res, _|
+          res << (0xff - number & 0xff)
+          number >>= 8
+          res
+        end
+      end
+
+      def to_string(param)
+        chars = param.map { |b| 0xff - b }
+        chars[0..-1].pack("C*").sub(/\0+$/, '')
+      end
+
+      def from_string(string, bytes)
+        chars = string.bytes
+        chars = chars[0...16].fill(0, chars.length, bytes - chars.length)
+        chars.map { |b| 0xff - b }
+      end
+
+      def checksum(bytes)
+        result = bytes.sum
+        [result >> 8, result & 0xff]
+      end
+    end
+  end
+end

data/lib/sdn/messages/post.rb

@@ -0,0 +1,162 @@
+module SDN
+  class Message
+    class PostMotorPosition < Message
+      MSG = 0x0d
+      PARAMS_LENGTH = 5
+
+      attr_accessor :position_pulses, :position_percent, :ip
+
+      def parse(params)
+        super
+        self.position_pulses = to_number(params[0..1], nillable: true)
+        self.position_percent = to_number(params[2], nillable: true)
+        self.ip = to_number(params[4], nillable: true)
+      end
+    end
+
+    class PostMotorStatus < Message
+      MSG = 0x0f
+      PARAMS_LENGTH = 4
+      STATE = { stopped: 0x00, running: 0x01, blocked: 0x02, locked: 0x03 }.freeze
+      DIRECTION = { down: 0x00, up: 0x01 }.freeze
+      SOURCE = { internal: 0x00, network: 0x01, dct: 0x02 }.freeze
+      CAUSE = { target_reached: 0x00,
+                explicit_command: 0x01,
+                wink: 0x02,
+                limits_not_set: 0x10,
+                ip_not_set: 0x11,
+                polarity_not_checked: 0x12,
+                in_configuration_mode: 0x13,
+                obstacle_detection: 0x20,
+                over_current_protection: 0x21,
+                thermal_protection: 0x22 }.freeze
+
+      attr_accessor :state, :last_direction, :last_action_source, :last_action_cause
+
+      def parse(params)
+        super
+        self.state = STATE.invert[to_number(params[0])]
+        self.last_direction = DIRECTION.invert[to_number(params[1])]
+        self.last_action_source = SOURCE.invert[to_number(params[2])]
+        self.last_action_cause = CAUSE.invert[to_number(params[3])]
+      end
+    end
+
+    class PostMotorLimits < Message
+      MSG = 0x31
+      PARAMS_LENGTH = 4
+
+      attr_accessor :up_limit, :down_limit
+
+      def parse(params)
+        super
+        self.up_limit = to_number(params[0..1], nillable: true)
+        self.down_limit = to_number(params[2..3], nillable: true)
+      end
+    end
+
+    class PostMotorDirection < Message
+      MSG = 0x32
+      PARAMS_LENGTH = 1
+      DIRECTION = { standard: 0x00, reversed: 0x01 }.freeze
+
+      attr_accessor :direction
+
+      def parse(params)
+        super
+        self.direction = DIRECTION.invert[to_number(params[0])]
+      end
+    end
+
+    class PostMotorRollingSpeed < Message
+      MSG = 0x33
+      PARAMS_LENGTH = 6
+
+      attr_accessor :up_speed, :down_speed, :slow_speed
+
+      def parse(params)
+        super
+        self.up_speed = to_number(params[0])
+        self.down_speed = to_number(params[1])
+        self.slow_speed = to_number(params[2])
+        # 3 ignored params
+      end
+    end
+
+    class PostMotorIP < Message
+      MSG = 0x35
+      PARAMS_LENGTH = 4
+
+      attr_accessor :ip, :position_pulses, :position_percent
+
+      def parse(params)
+        super
+        self.ip = to_number(params[0])
+        self.position_pulses = to_number(params[1..2], nillable: true)
+        self.position_percent = to_number(params[3], nillable: true)
+      end
+    end
+
+    class PostNodeAddr < Message
+      MSG = 0x60
+      PARAMS_LENGTH = 0
+    end
+
+    class PostGroupAddr < Message
+      MSG = 0x61
+      PARAMS_LENGTH = 4
+
+      attr_accessor :group_index, :group_address
+
+      def parse(params)
+        super
+        self.group_index = to_number(params[0])
+        self.group_address = transform_param(params[1..3])
+        self.group_address = nil if group_address == [0, 0, 0] || group_address == [0x01, 0x01, 0xff]
+      end
+
+      def class_inspect
+        ", group_index=#{group_index.inspect}, group_address=#{group_address ? print_address(group_address) : 'nil'}"
+      end
+    end
+
+    class PostNodeLabel < Message
+      MSG = 0x65
+
+      attr_accessor :label
+
+      def parse(params)
+        @label = to_string(params)
+      end
+    end
+
+    class PostNodeSerialNumber < Message
+      MSG = 0x6c
+
+      # format is NNNNNNMMYYWW
+      # N = NodeID (address)
+      # M = Manufacturer ID
+      # Y = Year (last two digits)
+      # W = Week
+      attr_accessor :serial_number
+
+      def parse(params)
+        @serial_number = to_string(params)
+      end
+    end
+
+    class PostNodeStackVersion < UnknownMessage
+      MSG = 0x71
+
+      attr_accessor :params
+
+      def parse(params)
+        # I don't know how to interpret this yet
+        # I get b6 bc b2 be fc fe, and UAI+ shows 5063497A3
+        super
+      end
+
+      def msg; MSG; end
+    end
+  end
+end