rmodbus-ccutrer 2.0.0 → 2.1.1

data/lib/rmodbus/client/slave.rb

@@ -1,4 +1,7 @@
-require 'timeout'
+# -*- coding: ascii
+# frozen_string_literal: true
+
+require "timeout"
 
 module ModBus
   class Client
@@ -8,15 +11,16 @@ module ModBus
       include Options
       # Number of times to retry on read and read timeouts
       attr_accessor :uid
-      Exceptions = {
-            1 => IllegalFunction.new("The function code received in the query is not an allowable action for the server"),
-            2 => IllegalDataAddress.new("The data address received in the query is not an allowable address for the server"),
-            3 => IllegalDataValue.new("A value contained in the query data field is not an allowable value for server"),
-            4 => SlaveDeviceFailure.new("An unrecoverable error occurred while the server was attempting to perform the requested action"),
-            5 => Acknowledge.new("The server has accepted the request and is processing it, but a long duration of time will be required to do so"),
-            6 => SlaveDeviceBus.new("The server is engaged in processing a long duration program command"),
-            8 => MemoryParityError.new("The extended file area failed to pass a consistency check")
-      }
+
+      EXCEPTIONS = {
+        1 => IllegalFunction,
+        2 => IllegalDataAddress,
+        3 => IllegalDataValue,
+        4 => SlaveDeviceFailure,
+        5 => Acknowledge,
+        6 => SlaveDeviceBus,
+        8 => MemoryParityError
+      }.freeze
       def initialize(uid, io)
         @uid = uid
         @io = io
@@ -44,7 +48,7 @@ module ModBus
       # @param [Integer] ncoils number coils
       # @return [Array] coils
       def read_coils(addr, ncoils = 1)
-        query("\x1" + addr.to_word + ncoils.to_word).unpack_bits[0..ncoils-1]
+        query("\x01#{addr.to_word}#{ncoils.to_word}").unpack_bits[0..ncoils - 1]
       end
 
       def read_coil(addr)
@@ -60,10 +64,10 @@ module ModBus
       # @param [Integer] val value coil (0 or other)
       # @return self
       def write_single_coil(addr, val)
-        if val == 0
-          query("\x5" + addr.to_word + 0.to_word)
+        if [0, false].include?(val)
+          query("\x05#{addr.to_word}\x00\x00")
         else
-          query("\x5" + addr.to_word + 0xff00.to_word)
+          query("\x05#{addr.to_word}\xff\x00")
         end
         self
       end
@@ -77,20 +81,20 @@ module ModBus
       # @param [Integer] addr address first coil
       # @param [Array] vals written coils
       def write_multiple_coils(addr, vals)
-        nbyte = ((vals.size-1) >> 3) + 1
+        nbyte = ((vals.size - 1) >> 3) + 1
         sum = 0
         (vals.size - 1).downto(0) do |i|
-          sum = sum << 1
-          sum |= 1 if vals[i] > 0
+          sum <<= 1
+          sum |= 1 if vals[i].positive?
         end
 
-        s_val = ""
+        s_val = +""
         nbyte.times do
           s_val << (sum & 0xff).chr
           sum >>= 8
         end
 
-        query("\xf" + addr.to_word + vals.size.to_word + nbyte.chr + s_val)
+        query("\x0f#{addr.to_word}#{vals.size.to_word}#{nbyte.chr}#{s_val}")
         self
       end
       alias_method :write_coils, :write_multiple_coils
@@ -115,7 +119,7 @@ module ModBus
       # @param[Integer] ninputs number inputs
       # @return [Array] inputs
       def read_discrete_inputs(addr, ninputs = 1)
-        query("\x2" + addr.to_word + ninputs.to_word).unpack_bits[0..ninputs-1]
+        query("\x02#{addr.to_word}#{ninputs.to_word}").unpack_bits[0..ninputs - 1]
       end
 
       def read_discrete_input(addr)
@@ -142,7 +146,7 @@ module ModBus
       # @param [Integer] nregs number registers
       # @return [Array] registers
       def read_input_registers(addr, nregs = 1)
-        query("\x4" + addr.to_word + nregs.to_word).unpack('n*')
+        query("\x04#{addr.to_word}#{nregs.to_word}").unpack("n*")
       end
 
       def read_input_register(addr)
@@ -171,7 +175,7 @@ module ModBus
       # @param [Integer] nregs number registers
       # @return [Array] registers
       def read_holding_registers(addr, nregs = 1)
-        query("\x3" + addr.to_word + nregs.to_word).unpack('n*')
+        query("\x03#{addr.to_word}#{nregs.to_word}").unpack("n*")
       end
 
       def read_holding_register(addr)
@@ -187,12 +191,11 @@ module ModBus
       # @param [Integer] val written to register
       # @return self
       def write_single_register(addr, val)
-        query("\x6" + addr.to_word + val.to_word)
+        query("\x06#{addr.to_word}#{val.to_word}")
         self
       end
       alias_method :write_holding_register, :write_single_register
 
-
       # Write multiple holding registers
       #
       # @example
@@ -202,12 +205,9 @@ module ModBus
       # @param [Array] val written registers
       # @return self
       def write_multiple_registers(addr, vals)
-        s_val = ""
-        vals.each do |reg|
-          s_val << reg.to_word
-        end
+        s_val = vals.map(&:to_word).join
 
-        query("\x10" + addr.to_word + vals.size.to_word + (vals.size * 2).chr + s_val)
+        query("\x10#{addr.to_word}#{vals.size.to_word}#{(vals.size * 2).chr}#{s_val}")
         self
       end
       alias_method :write_holding_registers, :write_multiple_registers
@@ -220,7 +220,7 @@ module ModBus
       # @param [Integer] and_mask mask for AND operation
       # @param [Integer] or_mask mask for OR operation
       def mask_write_register(addr, and_mask, or_mask)
-        query("\x16" + addr.to_word + and_mask.to_word + or_mask.to_word)
+        query("\x16#{addr.to_word}#{and_mask.to_word}#{or_mask.to_word}")
         self
       end
 
@@ -235,16 +235,16 @@ module ModBus
       # @param [Array] vals written registers
       # @return [Array] registers
       def read_write_multiple_registers(addr_r, nregs, addr_w, vals)
-        s_val = ""
-        vals.each do |reg|
-          s_val << reg.to_word
-        end
+        s_val = vals.map(&:to_word).join
 
-        query("\x17" + addr_r.to_word + nregs.to_word +
-                  addr_w.to_word + vals.size.to_word + (vals.size * 2).chr + s_val).unpack('n*')
+        query("\x17#{addr_r.to_word}#{nregs.to_word}#{addr_w.to_word}" \
+              "#{vals.size.to_word}#{(vals.size * 2).chr}#{s_val}")
+          .unpack("n*")
       end
       alias_method :read_write_holding_registers, :read_write_multiple_registers
 
+      # rubocop:disable Layout/LineLength
+
       # Request pdu to slave device
       #
       # @param [String] pdu request to slave
@@ -266,76 +266,64 @@ module ModBus
         begin
           ::Timeout.timeout(@read_retry_timeout, ModBusTimeout) do
             send_pdu(request)
-            response = read_pdu unless uid == 0
+            response = read_pdu unless uid.zero?
           end
-        rescue ModBusTimeout => err
+        rescue ModBusTimeout
           log "Timeout of read operation: (#{@read_retries - tried})"
           tried += 1
           retry unless tried >= @read_retries
           raise ModBusTimeout.new, "Timed out during read attempt"
         end
 
-        return nil if response.size == 0
+        return nil if response.empty?
 
         read_func = response.getbyte(0)
         if read_func >= 0x80
           exc_id = response.getbyte(1)
-          raise Exceptions[exc_id] unless Exceptions[exc_id].nil?
+          raise EXCEPTIONS[exc_id] unless EXCEPTIONS[exc_id].nil?
 
           raise ModBusException.new, "Unknown error"
         end
 
         check_response_mismatch(request, response) if raise_exception_on_mismatch
-        response[2..-1]
+        response[2..]
       end
+      # rubocop:enable Layout/LineLength
 
       private
+
       def check_response_mismatch(request, response)
         read_func = response.getbyte(0)
-        data = response[2..-1]
-        #Mismatch functional code
+        data = response[2..]
+        # Mismatch functional code
         send_func = request.getbyte(0)
-        if read_func != send_func
-          msg = "Function code is mismatch (expected #{send_func}, got #{read_func})"
-        end
+        msg = "Function code is mismatch (expected #{send_func}, got #{read_func})" if read_func != send_func
 
         case read_func
-        when 1,2
-          bc = request.getword(3)/8 + 1
-          if data.size != bc
-            msg = "Byte count is mismatch (expected #{bc}, got #{data.size} bytes)"
-          end
-        when 3,4
+        when 1, 2
+          bc = (request.getword(3) / 8) + 1
+          msg = "Byte count is mismatch (expected #{bc}, got #{data.size} bytes)" if data.size != bc
+        when 3, 4
           rc = request.getword(3)
-          if data.size/2 != rc
-            msg = "Register count is mismatch (expected #{rc}, got #{data.size/2} regs)"
-          end
-        when 5,6
+          msg = "Register count is mismatch (expected #{rc}, got #{data.size / 2} regs)" if data.size / 2 != rc
+        when 5, 6
           exp_addr = request.getword(1)
           got_addr = response.getword(1)
-          if exp_addr != got_addr
-            msg = "Address is mismatch (expected #{exp_addr}, got #{got_addr})"
-          end
+          msg = "Address is mismatch (expected #{exp_addr}, got #{got_addr})" if exp_addr != got_addr
 
           exp_val = request.getword(3)
           got_val = response.getword(3)
-          if exp_val != got_val
-            msg = "Value is mismatch (expected 0x#{exp_val.to_s(16)}, got 0x#{got_val.to_s(16)})"
-          end
-        when 15,16
+          msg = "Value is mismatch (expected 0x#{exp_val.to_s(16)}, got 0x#{got_val.to_s(16)})" if exp_val != got_val
+        when 15, 16
           exp_addr = request.getword(1)
           got_addr = response.getword(1)
-          if exp_addr != got_addr
-            msg = "Address is mismatch (expected #{exp_addr}, got #{got_addr})"
-          end
+          msg = "Address is mismatch (expected #{exp_addr}, got #{got_addr})" if exp_addr != got_addr
 
           exp_quant = request.getword(3)
           got_quant = response.getword(3)
-          if exp_quant != got_quant
-            msg = "Quantity is mismatch (expected #{exp_quant}, got #{got_quant})"
-          end
+          msg = "Quantity is mismatch (expected #{exp_quant}, got #{got_quant})" if exp_quant != got_quant
         else
-          warn "Fuiction (#{read_func}) is not supported raising response mismatch"
+          warn "Function (#{read_func}) is not supported raising response mismatch"
         end
 
         raise ResponseMismatch.new(msg, request, response) if msg

data/lib/rmodbus/client.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ModBus
   # @abstract
   class Client
-    autoload :Slave, 'rmodbus/client/slave'
+    autoload :Slave, "rmodbus/client/slave"
 
     include Errors
     include Debug
@@ -15,9 +17,9 @@ module ModBus
     # @param *args depends on implementation
     # @yield return client object and close it before exit
     # @return [Client] client object
-    def initialize(*args, &block)
+    def initialize(*args)
       # Defaults
-      @debug = false
+      @logger = nil
       @raise_exception_on_mismatch = false
       @read_retry_timeout = 1
       @read_retries = 1
@@ -47,9 +49,9 @@ module ModBus
     #
     # @param [Integer, #read] uid slave devise
     # @return [Slave] slave object
-    def with_slave(uid, &block)
+    def with_slave(uid)
       slave = get_slave(uid, @io)
-      slave.debug = debug
+      slave.logger = logger
       slave.raise_exception_on_mismatch = raise_exception_on_mismatch
       slave.read_retries = read_retries
       slave.read_retry_timeout = read_retry_timeout
@@ -72,22 +74,23 @@ module ModBus
     end
 
     protected
-    def open_connection(*args)
-      #Stub conn object
+
+    def open_connection(*)
+      # Stub conn object
       @io = Object.new
 
-      @io.instance_eval """
+      @io.instance_eval <<~RUBY, __FILE__, __LINE__ + 1
         def close
         end
 
         def closed?
           true
         end
-        """
+      RUBY
       @io
     end
 
-    def get_slave(uid,io)
+    def get_slave(uid, io)
       Slave.new(uid, io)
     end
   end

data/lib/rmodbus/debug.rb

@@ -1,16 +1,20 @@
-require 'time'
+# frozen_string_literal: true
+
+require "time"
 
 module ModBus
   module Debug
-    attr_accessor :debug, :raise_exception_on_mismatch,
-                  :read_retries, :read_retry_timeout
-
+    attr_accessor :raise_exception_on_mismatch,
+                  :read_retries,
+                  :read_retry_timeout,
+                  :logger
 
     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
+      logger&.debug(msg)
     end
 
     # Convert string of byte to string for log
@@ -19,7 +23,7 @@ module ModBus
     # @param [String] msg input string
     # @return [String] readable string of bytes
     def logging_bytes(msg)
-      msg.unpack("H*").first.gsub(/\X{2}/, "[\\0]")
+      msg.unpack1("H*").gsub(/\X{2}/, "[\\0]")
     end
   end
 end

data/lib/rmodbus/errors.rb

@@ -1,30 +1,53 @@
+# frozen_string_literal: true
+
 module ModBus
   module Errors
-    class ProxyException < StandardError
+    class ProxyException < RuntimeError
     end
 
-    class ModBusException < StandardError
+    class ModBusException < RuntimeError
     end
 
     class IllegalFunction < ModBusException
+      def initialize(msg = nil)
+        super(msg || "The function code received in the query is not an allowable action for the server")
+      end
     end
 
     class IllegalDataAddress < ModBusException
+      def initialize
+        super("The data address received in the query is not an allowable address for the server")
+      end
     end
 
     class IllegalDataValue < ModBusException
+      def initialize
+        super("A value contained in the query data field is not an allowable value for server")
+      end
     end
 
     class SlaveDeviceFailure < ModBusException
+      def initialize
+        super("An unrecoverable error occurred while the server was attempting to perform the requested action")
+      end
     end
 
     class Acknowledge < ModBusException
+      def initialize
+        super("The server has accepted the request and is processing it, but a long duration of time will be required to do so") # rubocop:disable Layout/LineLength
+      end
     end
 
     class SlaveDeviceBus < ModBusException
+      def initialize
+        super("The server is engaged in processing a long duration program command")
+      end
     end
 
     class MemoryParityError < ModBusException
+      def initialize
+        super("The extended file area failed to pass a consistency check")
+      end
     end
 
     class ModBusTimeout < ModBusException
@@ -32,6 +55,7 @@ module ModBus
 
     class ResponseMismatch < ModBusException
       attr_reader :request, :response
+
       def initialize(msg, request, response)
         super(msg)
         @request = request

data/lib/rmodbus/ext.rb

@@ -1,85 +1,106 @@
-class String
-
-  if RUBY_VERSION < "1.9"
-    def getbyte(index)
-      self[index].to_i
-    end
-  end
+# frozen_string_literal: true
 
+class String
+  # unpack a string of bytes into an array of integers (0 or 1)
+  # representing the bits in those bytes, according to how the
+  # ModBus protocol represents coils.
   def unpack_bits
-    array_bit = []
-    self.unpack('b*')[0].each_char do |c|
-        array_bit << c.to_i
+    result = []
+    each_byte do |b|
+      8.times do
+        # least significant bits first within each byte
+        result << (b & 0x01)
+        b >>= 1
+      end
     end
-    array_bit
+    result
   end
 
   # Get word by index
-  # @param [Integer] i index first bytes of word
+  # @param [Integer] index index first bytes of word
   # @return unpacked word
-  def getword(i)
-    self[i,2].unpack('n')[0]
+  def getword(index)
+    self[index, 2].unpack1("n")
   end
 end
 
 class Integer
-
-  # Shortcut or turning an integer into a word
+  # Shortcut for turning an integer into a word
   def to_word
-    [self].pack('n')
+    [self].pack("n")
   end
-
 end
 
 class Array
+  # Swap every pair of elements
+  def byteswap
+    even_elements_check
+    each_slice(2).flat_map(&:reverse)
+  end
+  alias_method :wordswap, :byteswap
 
-  # 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] }
+  # Given an array of 16-bit unsigned integers, turn it into an array of 16-bit signed integers.
+  def to_16i
+    pack("n*").unpack("s>*")
   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] }
+  # Given an array of 16-bit unsigned integers, turn it into an array of 32-bit floats, halving the size.
+  # The pairs of 16-bit elements should be in big endian order.
+  def to_32f
+    even_elements_check
+    pack("n*").unpack("g*")
   end
 
-  # Given an array of 32bit Floats, we turn it into an array of 16bit Fixnums, doubling the size
+  # Given an array of 32-bit floats, turn it into an array of 16-bit unsigned integers, doubling the size.
   def from_32f
-    self.pack('g*').unpack('n*').each_slice(2).map { |arr| arr.reverse }.flatten
+    pack("g*").unpack("n*")
+  end
+
+  # Given an array of 16-bit unsigned integers, turn it into 32-bit unsigned integers, halving the size.
+  # The pairs of 16-bit elements should be in big endian order.
+  def to_32u
+    even_elements_check
+    pack("n*").unpack("N*")
   end
 
-  # Given an array of 16bit Fixnum, we turn it into 32bit Float in big-endian order, halving the size
+  # Given an array of 16-bit unsigned integers, turn it into 32-bit signed integers, halving the size.
+  # The pairs of 16-bit elements should be in big endian order.
   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] }
+    even_elements_check
+    pack("n*").unpack("l>*")
   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
+  # Given an array of 32bit unsigned integers, turn it into an array of 16 bit unsigned integers, doubling the size
+  def from_32u
+    pack("N*").unpack("n*")
   end
 
-  def pack_to_word
-    word = 0
-    s = ""
-    mask = 0x01
+  # Given an array of 32bit signed integers, turn it into an array of 16 bit unsigned integers, doubling the size
+  def from_32i
+    pack("l>*").unpack("n*")
+  end
 
-    self.each do |bit|
-      word |= mask if bit > 0
-      mask <<= 1
-      if mask  == 0x100
-        mask = 0x01
-        s << word.chr
-        word = 0
+  # pack an array of bits into a string of bytes,
+  # as the ModBus protocol dictates for coils
+  def pack_bits
+    # pack each slice of 8 bits per byte,
+    # forward order (bits 0-7 in byte 0, 8-15 in byte 1, etc.)
+    # non-multiples of 8 are just 0-padded
+    each_slice(8).map do |slice|
+      byte = 0
+      # within each byte, bit 0 is the LSB,
+      # and bit 7 is the MSB
+      slice.reverse_each do |bit|
+        byte <<= 1
+        byte |= 1 if bit.positive?
       end
-    end
-    unless mask == 0x01
-      s << word.chr
-    else
-      s
-    end
+      byte
+    end.pack("C*")
   end
 
+  private
+
+  def even_elements_check
+    raise ArgumentError, "Array requires an even number of elements: was #{size}" unless size.even?
+  end
 end

data/lib/rmodbus/options.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module ModBus
   module Options
     attr_accessor :raise_exception_on_mismatch,
-                  :read_retries, :read_retry_timeout
+                  :read_retries,
+                  :read_retry_timeout
   end
 end

data/lib/rmodbus/proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # Given a slave and a type of operation, execute a single or multiple read using hash syntax
   class ReadOnlyProxy
@@ -10,9 +12,9 @@ module ModBus
     # 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)
+        @slave.send(:"read_#{@type}", key)
       elsif key.instance_of?(Range)
-        @slave.send("read_#{@type}s", key.first, key.count)
+        @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
@@ -20,22 +22,25 @@ module ModBus
   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
+    # 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)
+        @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})"
+          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)
+        @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