rmodbus-ccutrer 2.0.0

data/lib/rmodbus/debug.rb

@@ -0,0 +1,25 @@
+require 'time'
+
+module ModBus
+  module Debug
+    attr_accessor :debug, :raise_exception_on_mismatch,
+                  :read_retries, :read_retry_timeout
+
+
+    private
+    # Put log message on standard output
+    # @param [String] msg message for log
+    def log(msg)
+      $stdout.puts "#{Time.now.utc.iso8601(2)} #{msg}" if @debug
+    end
+
+    # Convert string of byte to string for log
+    # @example
+    #   logging_bytes("\x1\xa\x8") => "[01][0a][08]"
+    # @param [String] msg input string
+    # @return [String] readable string of bytes
+    def logging_bytes(msg)
+      msg.unpack("H*").first.gsub(/\X{2}/, "[\\0]")
+    end
+  end
+end

data/lib/rmodbus/errors.rb

@@ -0,0 +1,42 @@
+module ModBus
+  module Errors
+    class ProxyException < StandardError
+    end
+
+    class ModBusException < StandardError
+    end
+
+    class IllegalFunction < ModBusException
+    end
+
+    class IllegalDataAddress < ModBusException
+    end
+
+    class IllegalDataValue < ModBusException
+    end
+
+    class SlaveDeviceFailure < ModBusException
+    end
+
+    class Acknowledge < ModBusException
+    end
+
+    class SlaveDeviceBus < ModBusException
+    end
+
+    class MemoryParityError < ModBusException
+    end
+
+    class ModBusTimeout < ModBusException
+    end
+
+    class ResponseMismatch < ModBusException
+      attr_reader :request, :response
+      def initialize(msg, request, response)
+        super(msg)
+        @request = request
+        @response = response
+      end
+    end
+  end
+end

data/lib/rmodbus/ext.rb

@@ -0,0 +1,85 @@
+class String
+
+  if RUBY_VERSION < "1.9"
+    def getbyte(index)
+      self[index].to_i
+    end
+  end
+
+  def unpack_bits
+    array_bit = []
+    self.unpack('b*')[0].each_char do |c|
+        array_bit << c.to_i
+    end
+    array_bit
+  end
+
+  # Get word by index
+  # @param [Integer] i index first bytes of word
+  # @return unpacked word
+  def getword(i)
+    self[i,2].unpack('n')[0]
+  end
+end
+
+class Integer
+
+  # Shortcut or turning an integer into a word
+  def to_word
+    [self].pack('n')
+  end
+
+end
+
+class Array
+
+  # Given an array of 16bit Fixnum, we turn it into 32bit Int in big-endian order, halving the size
+  def to_32f
+    raise "Array requires an even number of elements to pack to 32bits: was #{self.size}" unless self.size.even?
+    self.each_slice(2).map { |(lsb, msb)| [msb, lsb].pack('n*').unpack('g')[0] }
+  end
+
+  # Given an array of 16bit Fixnum, we turn it into 32bit Int in little-endian order, halving the size
+  def to_32f_le
+    raise "Array requires an even number of elements to pack to 32bits: was #{self.size}" unless self.size.even?
+    self.each_slice(2).map { |(lsb, msb)| [lsb, msb].pack('n*').unpack('g')[0] }
+  end
+
+  # Given an array of 32bit Floats, we turn it into an array of 16bit Fixnums, doubling the size
+  def from_32f
+    self.pack('g*').unpack('n*').each_slice(2).map { |arr| arr.reverse }.flatten
+  end
+
+  # Given an array of 16bit Fixnum, we turn it into 32bit Float in big-endian order, halving the size
+  def to_32i
+    raise "Array requires an even number of elements to pack to 32bits: was #{self.size}" unless self.size.even?
+    self.each_slice(2).map { |(lsb, msb)| [msb, lsb].pack('n*').unpack('N')[0] }
+  end
+
+  # Given an array of 32bit Fixnum, we turn it into an array of 16bit fixnums, doubling the size
+  def from_32i
+    self.pack('N*').unpack('n*').each_slice(2).map { |arr| arr.reverse }.flatten
+  end
+
+  def pack_to_word
+    word = 0
+    s = ""
+    mask = 0x01
+
+    self.each do |bit|
+      word |= mask if bit > 0
+      mask <<= 1
+      if mask  == 0x100
+        mask = 0x01
+        s << word.chr
+        word = 0
+      end
+    end
+    unless mask == 0x01
+      s << word.chr
+    else
+      s
+    end
+  end
+
+end

data/lib/rmodbus/options.rb

@@ -0,0 +1,6 @@
+module ModBus
+  module Options
+    attr_accessor :raise_exception_on_mismatch,
+                  :read_retries, :read_retry_timeout
+  end
+end

data/lib/rmodbus/proxy.rb

@@ -0,0 +1,41 @@
+module ModBus
+  # Given a slave and a type of operation, execute a single or multiple read using hash syntax
+  class ReadOnlyProxy
+    # Initialize a proxy for a slave and a type of operation
+    def initialize(slave, type)
+      @slave, @type = slave, type
+    end
+
+    # Read single or multiple values from a modbus slave depending on whether a Fixnum or a Range was given.
+    # Note that in the case of multiples, a pluralized version of the method is sent to the slave
+    def [](key)
+      if key.instance_of?(0.class)
+        @slave.send("read_#{@type}", key)
+      elsif key.instance_of?(Range)
+        @slave.send("read_#{@type}s", key.first, key.count)
+      else
+        raise ModBus::Errors::ProxyException, "Invalid argument, must be integer or range. Was #{key.class}"
+      end
+    end
+  end
+
+  class ReadWriteProxy < ReadOnlyProxy
+    # Write single or multiple values to a modbus slave depending on whether a Fixnum or a Range was given.
+    # Note that in the case of multiples, a pluralized version of the method is sent to the slave. Also when
+    # writing multiple values, the number of elements must match the number of registers in the range or an exception is raised
+    def []=(key, val)
+      if key.instance_of?(0.class)
+        @slave.send("write_#{@type}", key, val)
+      elsif key.instance_of?(Range)
+        if key.count != val.size
+          raise ModBus::Errors::ProxyException, "The size of the range must match the size of the values (#{key.count} != #{val.size})"
+        end
+
+        @slave.send("write_#{@type}s", key.first, val)
+      else
+        raise ModBus::Errors::ProxyException, "Invalid argument, must be integer or range. Was #{key.class}"
+      end
+    end
+  end
+
+end

data/lib/rmodbus/rtu.rb

@@ -0,0 +1,122 @@
+require 'digest/crc16_modbus'
+require 'io/wait'
+
+module ModBus
+  module RTU
+    private
+
+    # We have to read specific amounts of numbers of bytes from the network depending on the function code and content
+    def read_rtu_response(io)
+	    # Read the slave_id and function code
+      msg = read(io, 2)
+      log logging_bytes(msg)
+
+      function_code = msg.getbyte(1)
+      case function_code
+        when 1,2,3,4 then
+          # read the third byte to find out how much more
+          # we need to read + CRC
+          msg += read(io, 1)
+          msg += read(io, msg.getbyte(2)+2)
+        when 5,6,15,16 then
+          # We just read in an additional 6 bytes
+          msg += read(io, 6)
+        when 22 then
+          msg += read(io, 8)
+        when 0x80..0xff then
+          msg += read(io, 3)
+        else
+          raise ModBus::Errors::IllegalFunction, "Illegal function: #{function_code}"
+      end
+    end
+
+    def clean_input_buff
+      # empty the input buffer
+      if @io.class.public_method_defined? :flush_input
+        @io.flush_input
+      else
+        @io.flush
+      end
+    end
+
+    def read(io, len)
+      result = ""
+      loop do
+        this_iter = io.read(len - result.length)
+        result.concat(this_iter) if this_iter
+        return result if result.length == len
+        io.wait_readable
+      end
+    end
+
+    def read_rtu_request(io)
+			# Every message is a minimum of 4 bytes (slave id, function code, crc16)
+			msg = read(io, 4)
+
+			# If msg is nil, then our client never sent us anything and it's time to disconnect
+			return if msg.nil?
+
+      loop do
+        offset = 0
+        crc = msg[-2..-1].unpack("S<").first
+
+        # scan the bytestream for a valid CRC
+        loop do
+          break if offset >= msg.length - 3
+          calculated_crc = Digest::CRC16Modbus.checksum(msg[offset..-3])
+          if crc == calculated_crc
+            is_response = (msg.getbyte(offset + 1) & 0x80 == 0x80) ||
+              (msg.getbyte(offset) == @last_req_uid &&
+                  msg.getbyte(offset + 1) == @last_req_func &&
+              @last_req_timestamp && Time.now.to_f - @last_req_timestamp < 5)
+
+            params = is_response ? parse_response(msg.getbyte(offset + 1), msg[(offset + 1)..-3]) :
+                parse_request(msg.getbyte(offset + 1), msg[(offset + 1)..-3])
+
+            unless params.nil?
+              if is_response
+                @last_req_uid = @last_req_func = @last_req_timestamp = nil
+              else
+                @last_req_uid = msg.getbyte(offset)
+                @last_req_func = msg.getbyte(offset + 1)
+                @last_req_timestamp = Time.now.to_f
+              end
+              log "Server RX discarding #{offset} bytes: #{logging_bytes(msg[0...offset])}" if offset != 0
+              log "Server RX (#{msg.size - offset} bytes): #{logging_bytes(msg[offset..-1])}"
+              return [msg.getbyte(offset), msg.getbyte(offset + 1), params, msg[offset + 1..-3], is_response]
+            end
+          end
+          offset += 1
+        end
+
+        msg.concat(read(io, 1))
+        # maximum message size is 256, so that's as far as we have to
+        # be able to see at once
+        msg = msg[1..-1] if msg.length > 256
+      end
+		end
+
+    def serve(io)
+      loop do
+        # read the RTU message
+        uid, func, params, pdu, is_response = read_rtu_request(io)
+
+        next if uid.nil?
+
+        pdu = exec_req(uid, func, params, pdu, is_response: is_response)
+        next unless pdu
+
+        @last_req_uid = @last_req_func = @last_req_timestamp = nil
+        resp = uid.chr + pdu
+        resp << [crc16(resp)].pack("S<")
+        log "Server TX (#{resp.size} bytes): #{logging_bytes(resp)}"
+        io.write resp
+      end
+    end
+
+    # Calc CRC16 for massage
+    def crc16(msg)
+      Digest::CRC16Modbus.checksum(msg)
+    end
+  end
+end

data/lib/rmodbus/rtu_client.rb

@@ -0,0 +1,43 @@
+module ModBus
+  # RTU client implementation
+  # @example
+  #   RTUClient.connect('/dev/ttyS1', 9600) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @example
+  #   RTUClient.connect('127.0.0.1', 10002) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see TCP#open_tcp_connection
+  # @see SP#open_serial_port
+  # @see Client#initialize
+  class RTUClient < Client
+    include RTU
+    include SP
+    include TCP
+
+    protected
+    # Open serial port
+    def open_connection(port_or_ipaddr, arg = nil, opts = {})
+      if port_or_ipaddr.is_a?(IO) || port_or_ipaddr.respond_to?(:read)
+        port_or_ipaddr
+      elsif File.exist?(port_or_ipaddr) || port_or_ipaddr.start_with?('/dev') || port_or_ipaddr.start_with?('COM')
+        arg ||= 9600
+        open_serial_port(port_or_ipaddr, arg, opts)
+      else
+        arg ||= 10002
+        open_tcp_connection(port_or_ipaddr, arg, opts)
+      end
+    end
+
+    def get_slave(uid, io)
+      RTUSlave.new(uid, io)
+    end
+  end
+end

data/lib/rmodbus/rtu_server.rb

@@ -0,0 +1,48 @@
+module ModBus
+  # RTU server implementation
+  # @example
+  #   srv = RTUServer.new('/dev/ttyS1', 9600)
+  #   slave = srv.with_slave(1)
+  #   slave.coils = [1,0,1,1]
+  #   slave.discrete_inputs = [1,1,0,0]
+  #   slave.holding_registers = [1,2,3,4]
+  #   slave.input_registers = [1,2,3,4]
+  #   srv.debug = true
+  #   srv.start
+  class RTUServer
+    include Debug
+    include Server
+    include RTU
+    include SP
+
+    # Init RTU server
+    # @param [Integer] uid slave device
+    # @see SP#open_serial_port
+    def initialize(port, baud=9600, opts = {})
+      Thread.abort_on_exception = true
+      if port.is_a?(IO) || port.respond_to?(:read)
+        @sp = port
+      else
+        @sp = open_serial_port(port, baud, opts)
+      end
+    end
+
+    # Start server
+    def start
+      @serv = Thread.new do
+        serve(@sp)
+      end
+    end
+
+    # Stop server
+    def stop
+      Thread.kill(@serv)
+      @sp.close
+    end
+
+    # Join server
+    def join
+      @serv.join
+    end
+  end
+end

data/lib/rmodbus/rtu_slave.rb

@@ -0,0 +1,48 @@
+module ModBus
+  # RTU slave implementation
+  # @example
+  #   RTUClient.connect(port, baud, opts) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUClient#open_connection
+  # @see Client#with_slave
+  # @see Slave
+  class RTUSlave < Client::Slave
+    include RTU
+
+    private
+    # overide method for RTU implamentaion
+    # @see Slave#query
+    def send_pdu(pdu)
+      msg = @uid.chr + pdu
+      msg << [crc16(msg)].pack("S<")
+
+      clean_input_buff
+      @io.write msg
+
+      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+    end
+
+    # overide method for RTU implamentaion
+    # @see Slave#query
+    def read_pdu
+      msg = read_rtu_response(@io)
+
+      log "Rx (#{msg.size} bytes): " + logging_bytes(msg)
+
+      if msg.getbyte(0) == @uid
+        return msg[1..-3] if msg[-2,2].unpack('S<')[0] == crc16(msg[0..-3])
+        log "Ignore package: don't match CRC"
+      else
+        log "Ignore package: don't match uid ID"
+      end
+      loop do
+        #waite timeout
+        sleep(0.1)
+      end
+    end
+  end
+end