em-modbus 0.1.0

data/lib/modbus/client.rb

@@ -0,0 +1,64 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'uri'
+
+module Modbus
+
+  class Client
+
+
+    def initialize(uri)
+      @base_polling_interval = 1
+      @last_poll_time        = Time.now
+      @uri                   = URI uri
+    end
+
+
+    def connected(conn)
+      @conn = conn
+      schedule_next_poll
+    end
+
+
+    def disconnected(conn)
+      reconnect
+    end
+
+
+    def connect
+      EM.connect @uri.host, @uri.port, Modbus::Connection::TCPClient, self
+    end
+
+
+    private
+
+
+    def reconnect
+      EM.add_timer(5) { connect }
+    end
+
+
+    def schedule_next_poll
+      poll_time      = Time.now - @last_poll_time
+      next_poll_time = [@base_polling_interval - poll_time, @base_polling_interval*0.25].max
+
+      EM.add_timer(next_poll_time) do
+        @last_poll_time = Time.now
+        poll
+      end
+    end
+
+
+    def poll
+      # no-op
+    end
+
+
+    def transaction(timeout = 2)
+      yield Modbus::Transaction::Client.new @conn, timeout
+    end
+
+  end
+
+end

data/lib/modbus/connection/base.rb

@@ -0,0 +1,41 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+module Modbus
+  module Connection
+
+    class Base < EM::Connection
+
+
+      def initialize(handler)
+        @handler = handler
+        reset_buffer
+      end
+
+
+      def receive_data(data)
+        @buffer << data
+        analyze_buffer
+
+      rescue => e
+        # TODO log exception
+        # puts e.message
+        reset_buffer
+      end
+
+
+      def reset_buffer
+        @buffer = String.new
+      end
+
+
+      def analyze_buffer
+        success = transaction_class.recv_adu @buffer, self
+        analyze_buffer if success && !@buffer.empty?
+      end
+
+
+    end # Base
+
+  end # Connection
+end # Modbus

data/lib/modbus/connection/connection.rb

@@ -0,0 +1,7 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'modbus/connection/protocol_data'
+require 'modbus/connection/base'
+require 'modbus/connection/tcp_client'
+require 'modbus/connection/tcp_server'

data/lib/modbus/connection/protocol_data.rb

@@ -0,0 +1,78 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+
+
+  # Helper class for dealing with the modbus wire format.
+  #
+  class ProtocolData < ::Array
+
+
+    # Initializes a new ProtocolData instance. Unpacks a buffer string if given.
+    #
+    # @param buffer [String, Array] The buffer data. If it's a String, it's automatically unpacked.
+    #
+    def initialize(buffer = nil)
+      case buffer
+      when String
+        super buffer.unpack('C*')
+      when Array
+        super buffer
+      end
+    end
+
+
+    # Shifts two bytes off the from front of the array and interprets them as a word (network byte order).
+    #
+    # @return [Integer, NilClass] The shifted word or nil if there are not enough bytes.
+    #
+    def shift_word
+      return nil if size < 2
+      # self.shift(2).pack('C2').unpack('n').first
+      self.slice!(0,2).pack('C2').unpack('n').first
+    end
+
+
+    # Interprets a value as a word (network byte order) and pushes two bytes to the end of the array.
+    #
+    # @param word [Integer] The value to push.
+    #
+    def push_word(word)
+      self.concat [word].pack('n').unpack('C2')
+    end
+
+
+    # Shifts one bytes off the from front of the array.
+    #
+    # @return [Integer] The shifted byte.
+    #
+    def shift_byte
+      # self.shift
+      self.slice!(0,1).first
+    end
+
+
+    # Interprets a value as a byte (network byte order) and pushes the byte to the end of the array.
+    #
+    # @param byte [Integer] The value to push.
+    #
+    def push_byte(byte)
+      self.concat [byte].pack('C').unpack('C')
+    end
+
+
+    # Converts the array data into a string.
+    #
+    # @return [String] The data string (frozen).
+    #
+    def to_buffer
+      self.pack('C*').freeze
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/connection/tcp_client.rb

@@ -0,0 +1,82 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'rubygems'
+require 'eventmachine'
+
+module Modbus
+  module Connection
+
+    class TCPClient < Base
+
+
+      # Initializes a new connection instance.
+      #
+      # @param handler The managing handler object.
+      #
+      def initialize(handler)
+        super
+
+        @transaction_ident    = 0
+        @pending_transactions = []
+      end
+
+
+      # EM callback. Called when the TCP connection is sucessfully established.
+      #
+      def connection_completed
+        @handler.connected self
+      end
+
+
+      # EM callback. Called when the TCP connection is closed.
+      #
+      def unbind
+        @handler.disconnected self
+      end
+
+
+      # Creates a successor transaction identfication in the range of 0..65535
+      #
+      # @return [Integer] The transaction identification
+      #
+      def next_transaction_ident
+        @transaction_ident = @transaction_ident.succ.modulo 2**16
+      end
+
+
+      # Adds Transaction object to the list of tracked transactions
+      #
+      # @param transaction [Modbus::Transaction] The transaction object to add.
+      #
+      def track_transaction(transaction)
+        # TODO log "exception"
+        # puts "Too many pending pending transactions: #{@pending_transactions.size}" if @pending_transactions.size > 100
+        @pending_transactions << transaction
+      end
+
+
+      # Looks for a matching transaction in the internal store by a transaction ident and returns it if found.
+      #
+      # @param transaction_ident [Integer] The transaction ident to match.
+      # @return [Modbus::Transaction] The found Transaction object.
+      #
+      def pick_pending_transaction(transaction_ident)
+        transaction = @pending_transactions.find { |r| r.transaction_ident == transaction_ident }
+        @pending_transactions.delete transaction
+        transaction
+      end
+
+
+      private
+
+
+      def transaction_class
+        Modbus::Transaction::Client
+      end
+
+
+    end # TCPClient
+
+  end # Connection
+end # Modbus

data/lib/modbus/connection/tcp_server.rb

@@ -0,0 +1,36 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'forwardable'
+
+module Modbus
+  module Connection
+
+    class TCPServer < Base
+      extend Forwardable
+
+      def_delegator :@handler, :read_registers,   :read_registers
+      def_delegator :@handler, :write_registers,  :write_registers
+
+
+      def post_init
+        @handler.client_connected signature
+      end
+
+
+      def unbind
+        @handler.client_disconnected signature
+      end
+
+
+      private
+
+
+      def transaction_class
+        Modbus::Transaction::Server
+      end
+
+    end # TCPServer
+
+  end # Connection
+end # Modbus

data/lib/modbus/exceptions.rb

@@ -0,0 +1,106 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+  ClientError = Class.new StandardError
+  ModbusError = Class.new StandardError
+
+  class ModbusError < StandardError
+    attr_reader :code
+
+    def initialize(msg)
+      super
+      @code = self.class::CODE
+    end
+  end
+
+  class IllegalFunction < ModbusError
+    CODE = 0x01
+
+    def initialize(msg = 'ILLEGAL FUNCTION')
+      super
+    end
+  end
+
+  class IllegalDataAddress < ModbusError
+    CODE = 0x02
+
+    def initialize(msg = 'ILLEGAL DATA ADDRESS')
+      super
+    end
+  end
+
+  class IllegalDataValue < ModbusError
+    CODE = 0x03
+
+    def initialize(msg = 'ILLEGAL DATA VALUE')
+      super
+    end
+  end
+
+  class ServerDeviceFailure < ModbusError
+    CODE = 0x04
+
+    def initialize(msg = 'SERVER DEVICE FAILURE')
+      super
+    end
+  end
+
+  class Acknowledge < ModbusError
+    CODE = 0x05
+
+    def initialize(msg = 'ACKNOWLEDGE')
+      super
+    end
+  end
+
+  class ServerDeviceBusy < ModbusError
+    CODE = 0x06
+
+    def initialize(msg = 'SERVER DEVICE BUSY')
+      super
+    end
+  end
+
+  class MemoryParityError < ModbusError
+    CODE = 0x08
+
+    def initialize(msg = 'MEMORY PARITY ERROR')
+      super
+    end
+  end
+
+  class GatewayPathUnavailable < ModbusError
+    CODE = 0x0A
+
+    def initialize(msg = 'GATEWAY PATH UNAVAILABLE')
+      super
+    end
+  end
+
+  class GatewayTargetDeviceFailedToRespond < ModbusError
+    CODE = 0x0B
+
+    def initialize(msg = 'GATEWAY TARGET DEVICE FAILED TO RESPOND')
+      super
+    end
+  end
+
+  def self.find_exception(code)
+    exceptions = [
+      IllegalFunction,
+      IllegalDataAddress,
+      IllegalDataValue,
+      ServerDeviceFailure,
+      Acknowledge,
+      ServerDeviceBusy,
+      MemoryParityError,
+      GatewayPathUnavailable,
+      GatewayTargetDeviceFailedToRespond
+    ]
+
+    exceptions.find { |e| e::CODE == code } || RuntimeError
+  end
+
+end

data/lib/modbus/modbus.rb

@@ -0,0 +1,12 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+require 'modbus/exceptions'
+require 'modbus/pdu/pdu'
+require 'modbus/adu/adu'
+require 'modbus/transaction/transaction'
+require 'modbus/connection/connection'
+require 'modbus/register/register'
+require 'modbus/client'
+require 'modbus/server'

data/lib/modbus/pdu/exception.rb

@@ -0,0 +1,56 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+
+  class PDU
+
+    # PDU for modbus exception (response message)
+    #
+    class Exception < PDU
+      attr_accessor :exception_code
+
+
+      def self.create(func_code, error)
+        obj = self.new nil, func_code + 0x80
+        obj.exception_code = error.code
+        obj
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        @exception_code = data.shift_byte
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_byte @exception_code
+        data
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        2
+      end
+
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/pdu/pdu.rb

@@ -0,0 +1,87 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'modbus/pdu/exception'
+require 'modbus/pdu/read_input_status'
+require 'modbus/pdu/read_registers'
+require 'modbus/pdu/read_input_registers'
+require 'modbus/pdu/read_holding_registers'
+require 'modbus/pdu/write_multiple_registers'
+
+module Modbus
+
+
+  # Base class modelling a Modbus PDU (Protocol Data Unit)
+  #
+  class PDU
+
+    # Maps the Modbus function code to the corresponding class (for request messages)
+    REQ_PDU_MAP = {}
+    [
+      ReadInputStatusRequest,
+      ReadInputRegistersRequest,
+      ReadHoldingRegistersRequest,
+      WriteMultipleRegistersRequest
+    ].each { |klass| REQ_PDU_MAP[klass::FUNC_CODE] = klass }
+
+
+    # Maps the Modbus function code to the corresponding class (for response messages)
+    RSP_PDU_MAP = {}
+    [
+      ReadInputStatusResponse,
+      ReadInputRegistersResponse,
+      ReadHoldingRegistersResponse,
+      WriteMultipleRegistersResponse
+    ].each { |klass| RSP_PDU_MAP[klass::FUNC_CODE] = klass }
+
+
+    attr_reader :creation_time, :func_code
+
+
+    # Factory method for creating PDUs. Decodes a PDU from protocol data and returns a new PDU instance.
+    #
+    # @param type [Symbol] The type of PDU which should be created. Must be :request or :response.
+    # @param func_code [Integer] The modbus function code of the PDU
+    # @param data [Modbus::ProtocolData] The protocol data to decode.
+    # @return [Modbus::PDU] The created PDU instance.
+    #
+    def self.create(type, func_code, data)
+      map = { :request => REQ_PDU_MAP, :response => RSP_PDU_MAP }[type]
+      fail ArgumentError, "Type is expected to be :request or :response, got #{type}" unless map
+
+      # 0x80 is the offset in case of a modbus exception
+      klass = func_code > 0x80 ? PDU::Exception : map[func_code]
+      fail IllegalFunction, "Unknown function code 0x#{func_code.to_s(16)}" if klass.nil?
+
+      klass.new data, func_code
+    end
+
+
+    # Initializes a new PDU instance. Decodes from protocol data if given.
+    #
+    # @param data [Modbus::ProtocolData] The protocol data to decode.
+    # @param func_code [Fixnum] Modbus function code.
+    #
+    def initialize(data = nil, func_code = nil)
+      @creation_time = Time.now.utc
+      @func_code     = func_code || self.class::FUNC_CODE
+
+      self.decode data if data
+    end
+
+
+    # Encodes a PDU into protocol data.
+    #
+    # @return [Modbus::ProtocolData] The protocol data representation of this object.
+    #
+    def encode
+      data = ProtocolData.new
+      data.push_byte @func_code
+      data
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/pdu/read_holding_registers.rb

@@ -0,0 +1,26 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+
+  class PDU
+
+    # PDU for modbus function "read holding register" (request message)
+    #
+    class ReadHoldingRegistersRequest < ReadRegistersRequest
+      FUNC_CODE = 0x03
+    end
+
+
+    # PDU for modbus function "read holding register" (response message)
+    #
+    class ReadHoldingRegistersResponse < ReadRegistersResponse
+      FUNC_CODE = 0x03
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/pdu/read_input_registers.rb

@@ -0,0 +1,26 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+
+  class PDU
+
+    # PDU for modbus function "read input register" (request message)
+    #
+    class ReadInputRegistersRequest < ReadRegistersRequest
+      FUNC_CODE = 0x04
+    end
+
+
+    # PDU for modbus function "read input register" (response message)
+    #
+    class ReadInputRegistersResponse < ReadRegistersResponse
+      FUNC_CODE = 0x04
+    end
+
+  end
+
+end # Modbus
+
+