rmodbus 1.3.2 → 2.1.2

data/lib/rmodbus/server.rb

@@ -1,127 +1,270 @@
+# frozen_string_literal: true
+
 module ModBus
   # Module for implementation ModBus server
   module Server
-    Funcs = [1,2,3,4,5,6,15,16]
+    autoload :Slave, "rmodbus/server/slave"
+
+    attr_accessor :promiscuous, :request_callback, :response_callback
 
-    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers, :uid
-    @coils = []
-    @discrete_inputs = []
-    @holding_registers =[]
-    @input_registers = []
+    FUNCS = [1, 2, 3, 4, 5, 6, 15, 16, 22, 23].freeze
+
+    def with_slave(uid)
+      slave = slaves[uid] ||= Server::Slave.new
+      if block_given?
+        yield slave
+      else
+        slave
+      end
+    end
 
     private
 
-    def exec_req(req, coils, discrete_inputs, holding_registers, input_registers)
-      func = req.getbyte(0)
+    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.zero?
+        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
 
-      unless Funcs.include?(func)
-        params = { :err => 1 }
+        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
-          params = parse_read_func(req, coils, 2000)
-          if params[:err] == 0
-            val = coils[params[:addr],params[:quant]].pack_to_word
-            pdu = func.chr + val.size.chr + val
-          end
-        when 2
-          params = parse_read_func(req, discrete_inputs, 2000)
-          if params[:err] == 0
-            val = discrete_inputs[params[:addr],params[:quant]].pack_to_word
-            pdu = func.chr + val.size.chr + val
-          end
-        when 3
-          params = parse_read_func(req, holding_registers)
-          if params[:err] == 0
-            pdu = func.chr + (params[:quant] * 2).chr + holding_registers[params[:addr],params[:quant]].pack('n*')
-          end
-        when 4
-          params = parse_read_func(req, input_registers)
-          if params[:err] == 0
-            pdu = func.chr + (params[:quant] * 2).chr + input_registers[params[:addr],params[:quant]].pack('n*')
-          end
-        when 5
-          params = parse_write_coil_func(req)
-          if params[:err] == 0
-            coils[params[:addr]] = params[:val]
-            pdu = req
-          end
-        when 6
-          params = parse_write_register_func(req)
-          if params[:err] == 0
-            holding_registers[params[:addr]] = params[:val]
-            pdu = req
-          end
-        when 15
-          params = parse_write_multiple_coils_func(req)
-          if params[:err] == 0
-            coils[params[:addr],params[:quant]] = params[:val][0,params[:quant]]
-            pdu = req[0,5]
-          end
-        when 16
-          params = parse_write_multiple_registers_func(req)
-          if params[:err] == 0
-            holding_registers[params[:addr],params[:quant]] = params[:val][0,params[:quant]]
-            pdu = req[0,5]
-          end
+      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
 
-      if params[:err] == 0
-        pdu
+    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..].unpack_bits
+      when 3, 4, 23
+        return nil unless res.length == res[1].ord + 2
+
+        res[2..].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_bits
+          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_bits
+          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 = (func | 0x80).chr + params[:err].chr
+        pdu
       end
     end
 
-    def parse_read_func(req, field, quant_max=0x7d)
-      quant = req[3,2].unpack('n')[0]
+    def parse_read_func(req, expected_length = 5)
+      return nil if expected_length && req.length != expected_length
 
-      return { :err => 3} unless quant <= quant_max
+      { quant: req[3, 2].unpack1("n"), addr: req[1, 2].unpack1("n") }
+    end
 
-      addr = req[1,2].unpack('n')[0]
-      return { :err => 2 } unless addr + quant <= field.size
+    def validate_read_func(params, field, quant_max = 0x7d)
+      return 3 unless params[:quant] <= quant_max
 
-      return { :err => 0, :quant => quant, :addr => addr }
+      2 unless params[:addr] + params[:quant] <= field.size
     end
 
     def parse_write_coil_func(req)
-      addr = req[1,2].unpack('n')[0]
-      return { :err => 2 } unless addr <= @coils.size
+      return nil unless req.length == 5
 
-      val = req[3,2].unpack('n')[0]
-      return { :err => 3 } unless val == 0 or val == 0xff00
+      { addr: req[1, 2].unpack1("n"), val: req[3, 2].unpack1("n") }
+    end
+
+    def validate_write_coil_func(params, slave)
+      return 2 unless params[:addr] <= slave.coils.size
 
-      val = 1 if val == 0xff00
-      return { :err => 0, :addr => addr, :val => val }
+      3 unless params[:val].zero? || (params[:val] == 0xff00)
     end
 
     def parse_write_register_func(req)
-      addr = req[1,2].unpack('n')[0]
-      return { :err => 2 } unless addr <= @holding_registers.size
+      return nil unless req.length == 5
 
-      val = req[3,2].unpack('n')[0]
+      { addr: req[1, 2].unpack1("n"), val: req[3, 2].unpack1("n") }
+    end
 
-      return { :err => 0, :addr => addr, :val => val }
-	  end
+    def validate_write_register_func(params, slave)
+      2 unless params[:addr] <= slave.holding_registers.size
+    end
 
     def parse_write_multiple_coils_func(req)
-      params = parse_read_func(req, @coils)
+      return nil if req.length < 7
 
-      if params[:err] == 0
-        params = {:err => 0, :addr => params[:addr], :quant => params[:quant], :val => req[6,params[:quant]].unpack_bits }
-      end
+      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)
-      params = parse_read_func(req, @holding_registers)
+      return nil if req.length < 8
 
-      if params[:err] == 0
-        params = {:err => 0, :addr => params[:addr], :quant => params[:quant], :val => req[6,params[:quant] * 2].unpack('n*')}
-      end
+      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].unpack1("n"),
+        and_mask: req[3, 2].unpack1("n"),
+        or_mask: req[5, 2].unpack1("n")
+      }
+    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..]) }
+      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/sp.rb

@@ -1,36 +1,34 @@
+# frozen_string_literal: true
+
 begin
-  require 'serialport'
-rescue Exception => e
-  warn "[WARNING] Install `serialport` gem for use RTU protocols"
+  require "ccutrer-serialport"
+rescue LoadError
+  warn "[WARNING] Install `ccutrer-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 [String] port name serial ports ("/dev/ttyS0")
     # @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
+    # @option opts [Integer] :parity :none, :even or :odd
     # @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, @stop_bits, @parity = 8, 1, :none
 
       @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
+      CCutrer::SerialPort.new(@port, baud: @baud, data_bits: @data_bits, stop_bits: @stop_bits, parity: @parity)
     end
   end
 end

data/lib/rmodbus/tcp.rb

@@ -1,32 +1,31 @@
-require 'socket'
-require 'timeout'
+# frozen_string_literal: true
+
+require "socket"
 
 module ModBus
   module TCP
     include Errors
-    include Timeout
     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 [TCPSocket] socket
+    # @return [Socket] socket
     #
     # @raise [ModBusTimeout] timed out attempting to create connection
     def open_tcp_connection(ipaddr, port, opts = {})
       @ipaddr, @port = ipaddr, port
 
-      opts[:connect_timeout] ||= 1
+      timeout = opts[:connect_timeout] ||= 1
 
       io = nil
       begin
-        timeout(opts[:connect_timeout], ModBusTimeout) do
-          io = TCPSocket.new(@ipaddr, @port)
-        end
-      rescue ModBusTimeout => err
-        raise ModBusTimeout.new, 'Timed out attempting to create connection'
+        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

data/lib/rmodbus/tcp_client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # TCP client implementation
   # @example
@@ -13,6 +15,7 @@ module ModBus
     include TCP
 
     protected
+
     # Open TCP\IP connection
     def open_connection(ipaddr, port = 502, opts = {})
       open_tcp_connection(ipaddr, port, opts)

data/lib/rmodbus/tcp_server.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 begin
-  require 'gserver'
+  require "gserver"
 rescue
   warn "[WARNING] Install `gserver` gem for use TCPServer"
 end
@@ -7,16 +9,17 @@ end
 module ModBus
   # TCP server implementation
   # @example
-  #   srv = TCPServer.new(10002, 1)
-  #   srv.coils = [1,0,1,1]
-  #   srv.discrete_inputs = [1,1,0,0]
-  #   srv.holding_registers = [1,2,3,4]
-  #   srv.input_registers = [1,2,3,4]
-  #   srv.debug = true
+  #   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.logger = Logger.new($stdout)
   #   srv.start
-	class TCPServer < GServer
-		include Debug
-		include Server
+  class TCPServer < GServer
+    include Debug
+    include Server
 
     # Init server
     # @param [Integer] port listen port
@@ -24,40 +27,43 @@ module ModBus
     # @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, uid = 1, opts = {})
-			@uid = uid
-
-      warn "[WARNING] Please, use UID = 255. It will be fixed in the next release." if @uid != 0xff
-
+    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
+      super(port, opts[:host], 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?
+      until stopped?
         header = io.read(7)
-        tx_id = header[0,2]
-        proto_id = header[2,2]
-        len = header[4,2].unpack('n')[0]
+        tx_id = header[0, 2]
+        proto_id = header[2, 2]
+        len = header[4, 2].unpack1("n")
         unit_id = header.getbyte(6)
-        if proto_id == "\x00\x00"
-          req = io.read(len - 1)
-          if unit_id == @uid || unit_id == 0
-            log "Server RX (#{req.size} bytes): #{logging_bytes(req)}"
-
-            pdu = exec_req(req, @coils, @discrete_inputs, @holding_registers, @input_registers)
-
-            resp = tx_id + "\0\0" + (pdu.size + 1).to_word + @uid.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
+        next unless 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}\x00\x00#{(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

data/lib/rmodbus/tcp_slave.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # TCP slave implementation
   # @example
@@ -7,25 +9,26 @@ module ModBus
   #     end
   #   end
   #
-  # @see RTUViaTCPClient#open_connection
+  # @see TCP#open_tcp_connection
   # @see Client#with_slave
   # @see Slave
-  class TCPSlave < Slave
+  class TCPSlave < Client::Slave
     attr_reader :transaction
 
     # @see Slave::initialize
     def initialize(uid, io)
       @transaction = 0
-      super(uid, io)
+      super
     end
 
     private
+
     # overide method for RTU over TCP implamentaion
     # @see Slave#query
     def send_pdu(pdu)
-      @transaction = 0 if @transaction.next > 65535
+      @transaction = 0 if @transaction.next > 65_535
       @transaction += 1
-      msg = @transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @uid.chr + pdu
+      msg = "#{@transaction.to_word}\x00\x00#{(pdu.size + 1).to_word}#{@uid.chr}#{pdu}"
       @io.write msg
 
       log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
@@ -36,19 +39,17 @@ module ModBus
     def read_pdu
       loop do
         header = @io.read(7)
-        if header
-          trn = header[0,2].unpack('n')[0]
-          len = header[4,2].unpack('n')[0]
-          msg = @io.read(len-1)
-
-          log "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg)
-
-          if trn == @transaction
-            return msg
-          else
-            log "Transaction number mismatch. A packet is ignored."
-          end
-        end
+        next unless header
+
+        trn = header[0, 2].unpack1("n")
+        len = header[4, 2].unpack1("n")
+        msg = @io.read(len - 1)
+
+        log "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg)
+
+        return msg if trn == @transaction
+
+        log "Transaction number mismatch. A packet is ignored."
       end
     end
   end

data/lib/rmodbus/version.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
-  # Package version
-  VERSION = '1.3.2'
+  VERSION = "2.1.2"
 end