em-modbus 0.1.0

data/lib/modbus/pdu/read_input_status.rb

@@ -0,0 +1,147 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+
+  class PDU
+
+    # PDU for modbus function "read input status" (request message)
+    #
+    class ReadInputStatusRequest < PDU
+      FUNC_CODE = 0x02
+      
+      attr_accessor :start_addr, :bit_count
+
+
+      # Initializes a new PDU instance. Decodes from protocol data if given.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def initialize(data = nil, func_code = nil)
+        @start_addr = 0
+        @bit_count  = 0
+        super
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        @start_addr = data.shift_word
+        @bit_count  = data.shift_word
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_word @start_addr
+        data.push_word @bit_count
+        data
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        5
+      end
+
+
+      # Validates the PDU. Raises exceptions if validation fails.
+      #
+      def validate
+        fail ClientError, "Register count must be in (1..127), got '#{@bit_count.inspect}'" unless (1..127).include?(@bit_count)
+      end
+
+    end
+
+
+    # PDU for modbus function "read input status" (response message)
+    #
+    class ReadInputStatusResponse < PDU
+      FUNC_CODE = 0x02
+
+      attr_accessor :bit_values
+
+
+      # Initializes a new PDU instance. Decodes from protocol data if given.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def initialize(data = nil, func_code = nil)
+        @bit_values = []
+        super
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        byte_count = data.shift_byte
+        byte_count.times do
+          byte = data.shift_byte
+
+          8.times do |bit|
+            @bit_values.push byte[bit] == 1
+          end
+        end
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_byte byte_count
+        @bit_values.each do |value|
+          data.push_byte value
+        end
+        data
+      end
+
+
+      # Returns the length of the register values in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def byte_count
+        @bit_values.size
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        # +1 for func_code, +1 for byte_count
+        byte_count + 2
+      end
+
+
+      # Validates the PDU. Raises exceptions if validation fails.
+      #
+      def validate
+
+      end
+
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/pdu/read_registers.rb

@@ -0,0 +1,135 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+
+  class PDU
+
+    # Base class PDU for modbus function "read holding register" (request message)
+    #
+    class ReadRegistersRequest < PDU
+      attr_accessor :start_addr, :reg_count
+
+
+      # Initializes a new PDU instance. Decodes from protocol data if given.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def initialize(data = nil, func_code = nil)
+        @start_addr = 0
+        @reg_count  = 0
+        super
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        @start_addr = data.shift_word
+        @reg_count  = data.shift_word
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_word @start_addr
+        data.push_word @reg_count
+        data
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        5
+      end
+
+
+      # Validates the PDU. Raises exceptions if validation fails.
+      #
+      def validate
+        fail ClientError, "Register count must be in (1..127), got '#{@reg_count.inspect}'" unless (1..127).include?(@reg_count)
+      end
+
+    end
+
+
+    # PDU for modbus function "read holding register" (response message)
+    #
+    class ReadRegistersResponse < PDU
+      attr_accessor :reg_values
+
+
+      # Initializes a new PDU instance. Decodes from protocol data if given.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def initialize(data = nil, func_code = nil)
+        @reg_values = []
+        super
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        byte_count = data.shift_byte
+        byte_count.div(2).times { @reg_values.push data.shift_word }
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_byte byte_count
+        @reg_values.each { |value| data.push_word value }
+        data
+      end
+
+
+      # Returns the length of the register values in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def byte_count
+        @reg_values.size * 2
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        # +1 for func_code, +1 for byte_count
+        byte_count + 2
+      end
+
+
+      # Validates the PDU. Raises exceptions if validation fails.
+      #
+      def validate
+
+      end
+
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/pdu/write_multiple_registers.rb

@@ -0,0 +1,158 @@
+# 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 WriteMultipleRegistersRequest < PDU
+      FUNC_CODE = 0x10
+
+      attr_accessor :start_addr, :reg_values
+
+
+      # Initializes a new PDU instance. Decodes from protocol data if given.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def initialize(data = nil, func_code = nil)
+        @start_addr = 0
+        @reg_values = []
+        super
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        @start_addr = data.shift_word
+
+        reg_count = data.shift_word
+        fail ClientError, "Register count must be in (1..127), got #{reg_count}" unless (1..127).include?(reg_count)
+
+        byte_count = data.shift_byte
+        fail ClientError, "Byte count does not match available data, expected #{byte_count} bytes, got #{data.size} bytes." unless byte_count == data.size
+
+        reg_count.times { @reg_values.push data.shift_word }
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_word @start_addr
+        data.push_word reg_count
+        data.push_byte byte_count
+        @reg_values.each { |value| data.push_word value }
+        data
+      end
+
+
+      # Returns the length of the register values in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def byte_count
+        reg_count * 2
+      end
+
+
+      # Returns the number of registers to write.
+      #
+      # @return [Integer] The number of registers.
+      #
+      def reg_count
+        @reg_values.size
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        # +1 for func_code, +2 for starting address, +2 for reg_count, +1 for byte_count
+        byte_count + 6
+      end
+
+
+      # Validates the PDU. Raises exceptions if validation fails.
+      #
+      def validate
+
+      end
+
+    end
+
+
+    # PDU for modbus function "read holding register" (response message)
+    #
+    class WriteMultipleRegistersResponse < PDU
+      FUNC_CODE = 0x10
+
+      attr_accessor :start_addr, :reg_count
+
+
+      # Initializes a new PDU instance. Decodes from protocol data if given.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def initialize(data = nil, func_code = nil)
+        @start_addr = 0
+        @reg_count  = 0
+        super
+      end
+
+
+      # Decodes a PDU from protocol data.
+      #
+      # @param data [Modbus::ProtocolData] The protocol data to decode.
+      #
+      def decode(data)
+        @start_addr = data.shift_word
+        @reg_count  = data.shift_word
+      end
+
+
+      # Encodes a PDU into protocol data.
+      #
+      # @return [Modbus::ProtocolData] The protocol data representation of this object.
+      #
+      def encode
+        data = super
+        data.push_word @start_addr
+        data.push_word @reg_count
+        data
+      end
+
+
+      # Returns the length of the PDU in bytes.
+      #
+      # @return [Integer] The length.
+      #
+      def length
+        5
+      end
+
+
+      # Validates the PDU. Raises exceptions if validation fails.
+      #
+      def validate
+        fail ClientError, "Register count must be in (1..127), got '#{@reg_count.inspect}'" unless (1..127).include?(@reg_count)
+      end
+
+    end
+
+  end
+
+end # Modbus
+
+

data/lib/modbus/register/base.rb

@@ -0,0 +1,19 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+
+module Modbus
+
+  class Register
+    attr_reader :addr
+    attr_accessor :handler
+
+
+    def initialize(addr)
+      @addr = addr
+    end
+
+  end
+
+end

data/lib/modbus/register/bit_register.rb

@@ -0,0 +1,49 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+
+module Modbus
+
+  class BitRegister < Register
+
+    def initialize(addr)
+      super
+      @bits = {}
+    end
+
+
+    def update(bit, value)
+      fail ArgumentError unless (0..15).include? bit
+      fail ArgumentError unless [true, false].include? value
+      @bits[bit] = value
+    end
+
+
+    def value
+      result = 0
+
+      @bits.each do |bit, bit_value|
+        value = bit_value ? 1 : 0
+        result |= (value << bit)
+      end
+
+      result
+    end
+
+
+    def write(value)
+      return unless @handler
+
+      values = @bits.keys.map do |bit|
+        bit_value = value[bit] == 1
+        {:addr => [@addr, bit].join('.'), :value => bit_value}
+      end
+
+      @handler.write_values values
+    end
+
+  end
+
+
+end

data/lib/modbus/register/register.rb

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

data/lib/modbus/register/word_register.rb

@@ -0,0 +1,30 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+
+module Modbus
+
+  class WordRegister < Register
+    attr_reader :value
+
+
+    def initialize(addr)
+      super
+      @value = 0
+    end
+
+
+    def update(value)
+      fail ArgumentError unless (0..65535).include? value
+      @value = value
+    end
+
+
+    def write(value)
+      @handler.write_values [{:addr => @addr.to_s, :value => value}] if @handler
+    end
+
+  end
+
+end

data/lib/modbus/server.rb

@@ -0,0 +1,120 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'uri'
+
+module Modbus
+
+  class Server
+    attr_reader :registers
+
+
+    def initialize(uri, handler)
+      @uri       = URI uri
+      @handler   = handler
+      @registers = {}
+    end
+
+
+    def add_register(addr, handler = nil)
+      log.info "Adding register @ #{addr}"
+
+      reg_addr, bit = addr.split('.')
+      reg_addr = reg_addr.to_i
+
+      register_class = bit ? BitRegister : WordRegister
+      reg = get_register reg_addr, register_class
+      reg.handler = handler
+
+      value = bit ? false : 0
+      update_register addr, value
+
+      reg
+    end
+
+
+    def update_register(addr, value)
+      reg_addr, bit = addr.split('.')
+      reg = @registers.fetch reg_addr.to_i
+
+      case reg
+      when WordRegister
+        reg.update value
+      when BitRegister
+        reg.update bit.to_i, value
+      end
+    end
+
+
+    def start
+      EM.start_server @uri.host, @uri.port, Modbus::Connection::TCPServer, self
+    end
+
+
+    def client_connected(signature)
+      log.info "client connected (signature #{signature})"
+    end
+
+
+    def client_disconnected(signature)
+      log.info "client disconnected (signature #{signature})"
+    end
+
+
+    def read_registers(start_addr, reg_count)
+      (0..reg_count-1).map do |idx|
+        addr = start_addr + idx
+        read_register addr
+      end
+    end
+
+
+    def write_registers(start_addr, reg_values)
+      reg_values.each_with_index do |value, idx|
+        addr = start_addr + idx
+        write_register addr, value
+      end
+
+      reg_values.size
+    end
+
+
+    private
+
+
+    def log
+      @handler.log
+    end
+
+
+    def get_register(addr, klass)
+      @registers[addr] ||= klass.new(addr)
+    end
+
+
+    def read_register(addr)
+      reg = @registers.fetch addr
+      reg.value
+
+    rescue IndexError
+      log.warn "read_register @ #{addr} failed (IllegalDataAddress)"
+      fail IllegalDataAddress
+    rescue => e
+      log.warn "read_register @ #{addr} failed. Error: #{e.message} (#{e.class}), Line: #{e.backtrace.first}"
+    end
+
+
+    def write_register(addr, value)
+      reg = @registers.fetch addr
+      reg.write value
+
+    rescue IndexError
+      log.warn "write_register @ #{addr} failed (IllegalDataAddress)"
+      fail IllegalDataAddress
+    rescue => e
+      log.warn "write_register @ #{addr} failed. Error: #{e.message}, Line: #{e.backtrace.first}"
+    end
+
+  end
+
+end

data/lib/modbus/transaction/base.rb

@@ -0,0 +1,25 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+  module Transaction
+
+    class Base
+
+
+      # Initializes a new Transaction instance.
+      #
+      # @param conn [Modbus::Connection::TCPServer] An EM connection object to work on.
+      #
+      def initialize(conn)
+        @conn = conn
+      end
+
+    end # Base
+
+  end # Transaction
+
+end # Modbus
+
+