rmodbus-ccutrer 2.1.0 → 2.1.1

data/lib/rmodbus/rtu.rb

@@ -1,5 +1,7 @@
-require 'digest/crc16_modbus'
-require 'io/wait'
+# frozen_string_literal: true
+
+require "digest/crc16_modbus"
+require "io/wait"
 
 module ModBus
   module RTU
@@ -7,25 +9,25 @@ module ModBus
 
     # 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)      
+      # Read the slave_id and function code
+      msg = read(io, 2)
 
       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}"
+      when 1, 2, 3, 4
+        # 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
+        # We just read in an additional 6 bytes
+        msg + read(io, 6)
+      when 22
+        msg + read(io, 8)
+      when 0x80..0xff
+        msg + read(io, 3)
+      else
+        raise ModBus::Errors::IllegalFunction, "Illegal function: #{function_code}"
       end
     end
 
@@ -39,38 +41,43 @@ module ModBus
     end
 
     def read(io, len)
-      result = ""
+      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)
+      # 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?
+      # 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
+        crc = msg[-2..].unpack1("S<")
 
         # 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)
+                          (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])
+            params = if is_response
+                       parse_response(msg.getbyte(offset + 1), msg[(offset + 1)..-3])
+                     else
+                       parse_request(msg.getbyte(offset + 1), msg[(offset + 1)..-3])
+                     end
 
             unless params.nil?
               if is_response
@@ -81,7 +88,7 @@ module ModBus
                 @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])}"
+              log "Server RX (#{msg.size - offset} bytes): #{logging_bytes(msg[offset..])}"
               return [msg.getbyte(offset), msg.getbyte(offset + 1), params, msg[offset + 1..-3], is_response]
             end
           end
@@ -91,9 +98,9 @@ module ModBus
         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
+        msg = msg[1..] if msg.length > 256
       end
-		end
+    end
 
     def serve(io)
       loop do

data/lib/rmodbus/rtu_client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # RTU client implementation
   # @example
@@ -23,15 +25,16 @@ module ModBus
     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')
+      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
+        arg ||= 10_002
         open_tcp_connection(port_or_ipaddr, arg, opts)
       end
     end

data/lib/rmodbus/rtu_server.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # RTU server implementation
   # @example
@@ -18,13 +20,13 @@ module ModBus
     # Init RTU server
     # @param [Integer] uid slave device
     # @see SP#open_serial_port
-    def initialize(port, baud=9600, opts = {})
+    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
+      @sp = if port.is_a?(IO) || port.respond_to?(:read)
+              port
+            else
+              open_serial_port(port, baud, opts)
+            end
     end
 
     # Start server

data/lib/rmodbus/rtu_slave.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # RTU slave implementation
   # @example
@@ -14,6 +16,7 @@ module ModBus
     include RTU
 
     private
+
     # overide method for RTU implamentaion
     # @see Slave#query
     def send_pdu(pdu)
@@ -34,13 +37,14 @@ module ModBus
       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])
+        return msg[1..-3] if msg[-2, 2].unpack1("S<") == 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
+        # waite timeout
         sleep(0.1)
       end
     end

data/lib/rmodbus/rtu_via_tcp_server.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 begin
-  require 'gserver'
+  require "gserver"
 rescue
   warn "[WARNING] Install `gserver` gem for use RTUViaTCPServer"
 end
@@ -26,10 +28,10 @@ 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 = 10002, opts = {})
+    def initialize(port = 10_002, 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
   end
 end

data/lib/rmodbus/server/slave.rb

@@ -1,4 +1,6 @@
-require 'timeout'
+# frozen_string_literal: true
+
+require "timeout"
 
 module ModBus
   module Server
@@ -8,7 +10,7 @@ module ModBus
       def initialize
         @coils = []
         @discrete_inputs = []
-        @holding_registers =[]
+        @holding_registers = []
         @input_registers = []
       end
     end

data/lib/rmodbus/server.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module ModBus
   # Module for implementation ModBus server
   module Server
-    autoload :Slave, 'rmodbus/server/slave'
+    autoload :Slave, "rmodbus/server/slave"
 
     attr_accessor :promiscuous, :request_callback, :response_callback
 
-    Funcs = [1,2,3,4,5,6,15,16,22,23]
+    FUNCS = [1, 2, 3, 4, 5, 6, 15, 16, 22, 23].freeze
 
     def with_slave(uid)
       slave = slaves[uid] ||= Server::Slave.new
@@ -30,7 +32,7 @@ module ModBus
       end
       request_callback&.call(uid, func, params) unless is_response
 
-      if uid == 0
+      if uid.zero?
         slaves.each_key { |specific_uid| exec_req(specific_uid, func, params, pdu) }
         return
       end
@@ -46,9 +48,10 @@ module ModBus
         return
       end
 
-      unless Funcs.include?(func)
+      unless FUNCS.include?(func)
         log("Server RX unrecognized function #{func} to #{uid}")
         return unless slave
+
         return (func | 0x80).chr + 1.chr
       end
 
@@ -56,6 +59,7 @@ module ModBus
       @pending_response_req = params
 
       return unless slave
+
       pdu = process_func(func, slave, pdu, params)
       if response_callback
         res = parse_response(pdu.getbyte(0), pdu)
@@ -84,80 +88,87 @@ module ModBus
     end
 
     def parse_response(func, res)
-      if func & 0x80 == 0x80 && Funcs.include?(func & 0x7f)
+      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
+
+        res[2..].unpack_bits
       when 3, 4, 23
         return nil unless res.length == res[1].ord + 2
-        res[2..-1].unpack('n*')
+
+        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_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
+      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
@@ -169,38 +180,45 @@ module ModBus
 
     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] }
+
+      { quant: req[3, 2].unpack1("n"), addr: req[1, 2].unpack1("n") }
     end
 
-    def validate_read_func(params, field, quant_max=0x7d)
+    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
+
+      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] }
+
+      { 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
-      return 3 unless params[:val] == 0 or params[:val] == 0xff00
+
+      3 unless params[:val].zero? || (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] }
+
+      { addr: req[1, 2].unpack1("n"), val: req[3, 2].unpack1("n") }
     end
 
     def validate_write_register_func(params, slave)
-      return 2 unless params[:addr] <= slave.holding_registers.size
+      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
+      return nil if req.length != 6 + ((params[:quant] + 7) / 8)
+
+      params[:val] = req[6, params[:quant]].unpack_bits
       params
     end
 
@@ -210,9 +228,11 @@ module ModBus
 
     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*')
+      return nil if req.length != 6 + (params[:quant] * 2)
+
+      params[:val] = req[6, params[:quant] * 2].unpack("n*")
       params
     end
 
@@ -222,24 +242,28 @@ module ModBus
 
     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]
+        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..-1])}
+                 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

data/lib/rmodbus/sp.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 begin
-  require 'ccutrer-serialport'
-rescue Exception => e
+  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")
     # @param [Integer] baud rate serial port (default 9600)

data/lib/rmodbus/tcp.rb

@@ -1,9 +1,12 @@
-require 'socket'
+# frozen_string_literal: true
+
+require "socket"
 
 module ModBus
   module TCP
     include Errors
     attr_reader :ipaddr, :port
+
     # Open TCP socket
     #
     # @param [String] ipaddr IP address of remote server
@@ -22,7 +25,7 @@ module ModBus
       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'
+        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)