rmodbus-ccutrer 2.0.0

data/lib/rmodbus/rtu_via_tcp_server.rb

@@ -0,0 +1,35 @@
+begin
+  require 'gserver'
+rescue
+  warn "[WARNING] Install `gserver` gem for use RTUViaTCPServer"
+end
+
+module ModBus
+  # RTU over TCP server implementation
+  # @example
+  #   srv = RTUViaTCPServer.new(10002)
+  #   slave = src.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 RTUViaTCPServer < GServer
+    include Debug
+    include RTU
+    include Server
+
+    # Init server
+    # @param [Integer] port listen port
+    # @param [Integer] uid slave device
+    # @param [Hash] opts options of server
+    # @option opts [String] :host host of server default '127.0.0.1'
+    # @option opts [Float, Integer] :max_connection max of TCP connection with server default 4
+    def initialize(port = 10002, opts = {})
+      opts[:host] = DEFAULT_HOST unless opts[:host]
+      opts[:max_connection] = 4 unless opts[:max_connection]
+			super(port, host = opts[:host], maxConnection = opts[:max_connection])
+		end
+  end
+end

data/lib/rmodbus/server.rb

@@ -0,0 +1,246 @@
+module ModBus
+  # Module for implementation ModBus server
+  module Server
+    autoload :Slave, 'rmodbus/server/slave'
+
+    attr_accessor :promiscuous, :request_callback, :response_callback
+
+    Funcs = [1,2,3,4,5,6,15,16,22,23]
+
+    def with_slave(uid)
+      slave = slaves[uid] ||= Server::Slave.new
+      if block_given?
+        yield slave
+      else
+        slave
+      end
+    end
+
+    private
+
+    def slaves
+      @slaves ||= {}
+    end
+
+    def exec_req(uid, func, params, pdu, is_response: false)
+      if is_response
+        log("Server RX response #{func & 0x7f} from #{uid}: #{params.inspect}")
+      else
+        log("Server RX function #{func} to #{uid}: #{params.inspect}")
+      end
+      request_callback&.call(uid, func, params) unless is_response
+
+      if uid == 0
+        slaves.each_key { |specific_uid| exec_req(specific_uid, func, params, pdu) }
+        return
+      end
+      slave = slaves[uid]
+      return nil if !slave && !promiscuous
+
+      if promiscuous && !slave && is_response
+        # we saw a request to a slave that we don't own; try
+        # and parse this as a response, not a request
+
+        response_callback&.call(uid, func, params, @pending_response_req)
+        @pending_response_req = nil
+        return
+      end
+
+      unless Funcs.include?(func)
+        log("Server RX unrecognized function #{func} to #{uid}")
+        return unless slave
+        return (func | 0x80).chr + 1.chr
+      end
+
+      # keep track of the request so that promiscuous printing of the response can have context if necessary
+      @pending_response_req = params
+
+      return unless slave
+      pdu = process_func(func, slave, pdu, params)
+      if response_callback
+        res = parse_response(pdu.getbyte(0), pdu)
+        response_callback.call(uid, pdu.getbyte(0), res, params)
+      end
+      pdu
+    end
+
+    def parse_request(func, req)
+      case func
+      when 1, 2, 3, 4
+        parse_read_func(req)
+      when 5
+        parse_write_coil_func(req)
+      when 6
+        parse_write_register_func(req)
+      when 15
+        parse_write_multiple_coils_func(req)
+      when 16
+        parse_write_multiple_registers_func(req)
+      when 22
+        parse_mask_write_register_func(req)
+      when 23
+        parse_read_write_multiple_registers_func(req)
+      end
+    end
+
+    def parse_response(func, res)
+      if func & 0x80 == 0x80 && Funcs.include?(func & 0x7f)
+        return nil unless res.length == 2
+        return { err: res[1].ord }
+      end
+
+      case func
+      when 1, 2
+        return nil unless res.length == res[1].ord + 2
+        res[2..-1].unpack_bits
+      when 3, 4, 23
+        return nil unless res.length == res[1].ord + 2
+        res[2..-1].unpack('n*')
+      when 5, 6, 15, 16
+        return nil unless res.length == 5
+        {}
+      when 22
+        return nil unless res.length == 7
+        {}
+      end
+    end
+
+    def process_func(func, slave, req, params)
+      case func
+        when 1
+          unless (err = validate_read_func(params, slave.coils, 2000))
+            val = slave.coils[params[:addr],params[:quant]].pack_to_word
+            pdu = func.chr + val.size.chr + val
+          end
+        when 2
+          unless (err = validate_read_func(params, slave.discrete_inputs, 2000))
+            val = slave.discrete_inputs[params[:addr],params[:quant]].pack_to_word
+            pdu = func.chr + val.size.chr + val
+          end
+        when 3
+          unless (err = validate_read_func(params, slave.holding_registers))
+            pdu = func.chr + (params[:quant] * 2).chr + slave.holding_registers[params[:addr],params[:quant]].pack('n*')
+          end
+        when 4
+          unless (err = validate_read_func(params, slave.input_registers))
+            pdu = func.chr + (params[:quant] * 2).chr + slave.input_registers[params[:addr],params[:quant]].pack('n*')
+          end
+        when 5
+          unless (err = validate_write_coil_func(params, slave))
+            params[:val] = 1 if params[:val] == 0xff00
+            slave.coils[params[:addr]] = params[:val]
+            pdu = req
+          end
+        when 6
+          unless (err = validate_write_register_func(params, slave))
+            slave.holding_registers[params[:addr]] = params[:val]
+            pdu = req
+          end
+        when 15
+          unless (err = validate_write_multiple_coils_func(params, slave))
+            slave.coils[params[:addr],params[:quant]] = params[:val][0,params[:quant]]
+            pdu = req[0,5]
+          end
+        when 16
+          unless (err = validate_write_multiple_registers_func(params, slave))
+            slave.holding_registers[params[:addr],params[:quant]] = params[:val]
+            pdu = req[0,5]
+          end
+        when 22
+          unless (err = validate_write_register_func(params, slave))
+            addr = params[:addr]
+            and_mask = params[:and_mask]
+            slave.holding_registers[addr] = (slave.holding_registers[addr] & and_mask) | (params[:or_mask] & ~and_mask)
+            pdu = req
+          end
+        when 23
+          unless (err = validate_read_write_multiple_registers_func(params, slave))
+            slave.holding_registers[params[:write][:addr],params[:write][:quant]] = params[:write][:val]
+            pdu = func.chr + (params[:read][:quant] * 2).chr + slave.holding_registers[params[:read][:addr],params[:read][:quant]].pack('n*')
+          end
+      end
+
+      if err
+        (func | 0x80).chr + err.chr
+      else
+        pdu
+      end
+    end
+
+    def parse_read_func(req, expected_length = 5)
+      return nil if expected_length && req.length != expected_length
+      { quant: req[3,2].unpack('n')[0], addr: req[1,2].unpack('n')[0] }
+    end
+
+    def validate_read_func(params, field, quant_max=0x7d)
+      return 3 unless params[:quant] <= quant_max
+      return 2 unless params[:addr] + params[:quant] <= field.size
+    end
+
+    def parse_write_coil_func(req)
+      return nil unless req.length == 5
+      { addr: req[1,2].unpack('n')[0], val: req[3,2].unpack('n')[0] }
+    end
+
+    def validate_write_coil_func(params, slave)
+      return 2 unless params[:addr] <= slave.coils.size
+      return 3 unless params[:val] == 0 or params[:val] == 0xff00
+    end
+
+    def parse_write_register_func(req)
+      return nil unless req.length == 5
+      { addr: req[1,2].unpack('n')[0], val: req[3,2].unpack('n')[0] }
+    end
+
+    def validate_write_register_func(params, slave)
+      return 2 unless params[:addr] <= slave.holding_registers.size
+    end
+
+    def parse_write_multiple_coils_func(req)
+      return nil if req.length < 7
+      params = parse_read_func(req, nil)
+      return nil if req.length != 6 + (params[:quant] + 7) / 8
+      params[:val] = req[6,params[:quant]].unpack_bits
+      params
+    end
+
+    def validate_write_multiple_coils_func(params, slave)
+      validate_read_func(params, slave.coils)
+    end
+
+    def parse_write_multiple_registers_func(req)
+      return nil if req.length < 8
+      params = parse_read_func(req, nil)
+      return nil if req.length != 6 + params[:quant] * 2
+      params[:val] = req[6,params[:quant] * 2].unpack('n*')
+      params
+    end
+
+    def validate_write_multiple_registers_func(params, slave)
+      validate_read_func(params, slave.holding_registers)
+    end
+
+    def parse_mask_write_register_func(req)
+      return nil if req.length != 7
+      {
+          addr: req[1,2].unpack('n')[0],
+          and_mask: req[3,2].unpack('n')[0],
+          or_mask: req[5,2].unpack('n')[0]
+      }
+    end
+
+    def parse_read_write_multiple_registers_func(req)
+      return nil if req.length < 12
+      params = { read: parse_read_func(req, nil),
+        write: parse_write_multiple_registers_func(req[4..-1])}
+      return nil if params[:write].nil?
+      params
+    end
+
+    def validate_read_write_multiple_registers_func(params, slave)
+      result = validate_read_func(params[:read], slave.holding_registers)
+      return result if result
+      validate_write_multiple_registers_func(params[:write], slave)
+    end
+  end
+end

data/lib/rmodbus/server/slave.rb

@@ -0,0 +1,16 @@
+require 'timeout'
+
+module ModBus
+  module Server
+    class Slave
+      attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers
+
+      def initialize
+        @coils = []
+        @discrete_inputs = []
+        @holding_registers =[]
+        @input_registers = []
+      end
+    end
+  end
+end

data/lib/rmodbus/sp.rb

@@ -0,0 +1,36 @@
+begin
+  require 'serialport'
+rescue Exception => e
+  warn "[WARNING] Install `serialport` gem for use RTU protocols"
+end
+
+module ModBus
+  module SP
+    attr_reader :port, :baud, :data_bits, :stop_bits, :parity, :read_timeout
+    # Open serial port
+    # @param [String] port name serial ports ("/dev/ttyS0" POSIX, "com1" - Windows)
+    # @param [Integer] baud rate serial port (default 9600)
+    # @param [Hash] opts the options of serial port
+    #
+    # @option opts [Integer] :data_bits from 5 to 8
+    # @option opts [Integer] :stop_bits 1 or 2
+    # @option opts [Integer] :parity NONE, EVEN or ODD
+    # @option opts [Integer] :read_timeout default 100 ms
+    # @return [SerialPort] io serial port
+    def open_serial_port(port, baud, opts = {})
+      @port, @baud = port, baud
+
+      @data_bits, @stop_bits, @parity, @read_timeout = 8, 1, SerialPort::NONE, 100
+
+      @data_bits = opts[:data_bits] unless opts[:data_bits].nil?
+      @stop_bits = opts[:stop_bits] unless opts[:stop_bits].nil?
+      @parity = opts[:parity] unless opts[:parity].nil?
+      @read_timeout = opts[:read_timeout] unless opts[:read_timeout].nil?
+
+      io = SerialPort.new(@port, @baud, @data_bits, @stop_bits, @parity)
+      io.flow_control = SerialPort::NONE
+      io.read_timeout = @read_timeout
+      io
+    end
+  end
+end

data/lib/rmodbus/tcp.rb

@@ -0,0 +1,31 @@
+require 'socket'
+
+module ModBus
+  module TCP
+    include Errors
+    attr_reader :ipaddr, :port
+    # Open TCP socket
+    #
+    # @param [String] ipaddr IP address of remote server
+    # @param [Integer] port connection port
+    # @param [Hash] opts options of connection
+    # @option opts [Float, Integer] :connect_timeout seconds timeout for open socket
+    # @return [Socket] socket
+    #
+    # @raise [ModBusTimeout] timed out attempting to create connection
+    def open_tcp_connection(ipaddr, port, opts = {})
+      @ipaddr, @port = ipaddr, port
+
+      timeout = opts[:connect_timeout] ||= 1
+
+      io = nil
+      begin
+        io = Socket.tcp(@ipaddr, @port, nil, nil, connect_timeout: timeout)
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+        raise ModBusTimeout.new, 'Timed out attempting to create connection'
+      end
+
+      io
+    end
+  end
+end

data/lib/rmodbus/tcp_client.rb

@@ -0,0 +1,25 @@
+module ModBus
+  # TCP client implementation
+  # @example
+  #   TCPClient.connect('127.0.0.1', 502) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see TCP#open_tcp_connection
+  # @see Client#initialize
+  class TCPClient < Client
+    include TCP
+
+    protected
+    # Open TCP\IP connection
+    def open_connection(ipaddr, port = 502, opts = {})
+      open_tcp_connection(ipaddr, port, opts)
+    end
+
+    def get_slave(uid, io)
+      TCPSlave.new(uid, io)
+    end
+  end
+end

data/lib/rmodbus/tcp_server.rb

@@ -0,0 +1,67 @@
+begin
+  require 'gserver'
+rescue
+  warn "[WARNING] Install `gserver` gem for use TCPServer"
+end
+
+module ModBus
+  # TCP server implementation
+  # @example
+  #   srv = TCPServer.new(10002)
+  #   slave = srv.with_slave(255)
+  #   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 TCPServer < GServer
+		include Debug
+		include Server
+
+    # Init server
+    # @param [Integer] port listen port
+    # @param [Integer] uid slave device
+    # @param [Hash] opts options of server
+    # @option opts [String] :host host of server default '127.0.0.1'
+    # @option opts [Float, Integer] :max_connection max of TCP connection with server default 4
+		def initialize(port = 502, opts = {})
+      opts[:host] = DEFAULT_HOST unless opts[:host]
+      opts[:max_connection] = 4 unless opts[:max_connection]
+			super(port, host = opts[:host], maxConnection = opts[:max_connection])
+		end
+
+    # set the default param
+    def with_slave(uid = 255)
+      super
+    end
+
+    # Serve requests
+    # @param [TCPSocket] io socket
+    def serve(io)
+      while not stopped?
+        header = io.read(7)
+        tx_id = header[0,2]
+        proto_id = header[2,2]
+        len = header[4,2].unpack('n')[0]
+        unit_id = header.getbyte(6)
+        if proto_id == "\x00\x00"
+          req = io.read(len - 1)
+          log "Server RX (#{req.size} bytes): #{logging_bytes(req)}"
+
+          func = req.getbyte(0)
+          params = parse_request(func, req)
+          pdu = exec_req(unit_id, func, params, req)
+
+          if pdu
+            resp = tx_id + "\0\0" + (pdu.size + 1).to_word + unit_id.chr + pdu
+            log "Server TX (#{resp.size} bytes): #{logging_bytes(resp)}"
+            io.write resp
+          else
+            log "Ignored server RX (invalid unit ID #{unit_id}, #{req.size} bytes): #{logging_bytes(req)}"
+          end
+        end
+      end
+    end
+	end
+end