rmodbus 1.3.2 → 2.1.2

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, 1)
+        @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

data/lib/rmodbus/rtu.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
+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 = nil
-      while msg.nil?
-	      msg = io.read(2)
-      end
+      # 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 += io.read(1)
-          msg += io.read(msg.getbyte(2)+2)
-        when 5,6,15,16 then
-          # We just read in an additional 6 bytes
-          msg += io.read(6)
-        when 22 then
-          msg += io.read(8)
-        when 0x80..0xff then
-          msg += io.read(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
 
@@ -38,127 +40,89 @@ module ModBus
       end
     end
 
-    def send_rtu_pdu(pdu)
-      msg = @uid.chr + pdu
-      msg << crc16(msg).to_word
-
-      clean_input_buff
-      @io.write msg
+    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
 
-      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+        io.wait_readable
+      end
     end
 
-    def read_rtu_pdu
-      msg = read_rtu_response(@io)
+    def read_rtu_request(io)
+      # Every message is a minimum of 4 bytes (slave id, function code, crc16)
+      msg = read(io, 4)
 
-      log "Rx (#{msg.size} bytes): " + logging_bytes(msg)
+      # If msg is nil, then our client never sent us anything and it's time to disconnect
+      return if msg.nil?
 
-      if msg.getbyte(0) == @uid
-        return msg[1..-3] if msg[-2,2].unpack('n')[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)
+        offset = 0
+        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)
+
+            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
+                @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..])}"
+              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..] if msg.length > 256
       end
     end
 
-    def read_rtu_request(io)
-			# Read the slave_id and function code
-			msg = io.read(2)
-
-			# If msg is nil, then our client never sent us anything and it's time to disconnect
-			return if msg.nil?
-
-			function_code = msg.getbyte(1)
-			if [1, 2, 3, 4, 5, 6].include?(function_code)
-				# read 6 more bytes and return the message total message
-				msg += io.read(6)
-			elsif [15, 16].include?(function_code)
-				# Read in first register, register count, and data bytes
-				msg += io.read(5)
-				# Read in however much data we need to + 2 CRC bytes
-				msg += io.read(msg.getbyte(6) + 2)
-			else
-				raise ModBus::Errors::IllegalFunction, "Illegal function: #{function_code}"
-			end
-
-			log "Server RX (#{msg.size} bytes): #{logging_bytes(msg)}"
-
-			msg
-		end
-
-    def serv_rtu_requests(io, &blk)
+    def serve(io)
       loop do
         # read the RTU message
-        msg = read_rtu_request(io)
-
-        next if msg.nil?
-
-        if msg.getbyte(0) == @uid and msg[-2,2].unpack('n')[0] == crc16(msg[0..-3])
-          pdu = yield msg
-          resp = @uid.chr + pdu
-          resp << crc16(resp).to_word
-          log "Server TX (#{resp.size} bytes): #{logging_bytes(resp)}"
-          io.write resp
-		    end
-	    end
-    end
+        uid, func, params, pdu, is_response = read_rtu_request(io)
 
-    # Calc CRC16 for massage
-    def crc16(msg)
-      crc_lo = 0xff
-      crc_hi = 0xff
+        next if uid.nil?
 
-      msg.unpack('c*').each do |byte|
-        i = crc_hi ^ byte
-        crc_hi = crc_lo ^ CrcHiTable[i]
-        crc_lo = CrcLoTable[i]
-      end
+        pdu = exec_req(uid, func, params, pdu, is_response: is_response)
+        next unless pdu
 
-      return ((crc_hi << 8) + crc_lo)
+        @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
 
-    CrcHiTable = [
-        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
-        0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
-        0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
-        0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
-        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
-        0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
-        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
-        0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
-        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
-        0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
-        0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
-        0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
-        0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
-        0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
-        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
-        0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
-        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
-        0x40]
-    CrcLoTable = [
-        0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
-        0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
-        0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
-        0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
-        0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
-        0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
-        0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
-        0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
-        0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
-        0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
-        0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
-        0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
-        0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
-        0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
-        0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
-        0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
-        0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
-        0x40]
-
+    # Calc CRC16 for massage
+    def crc16(msg)
+      Digest::CRC16Modbus.checksum(msg)
+    end
   end
 end

data/lib/rmodbus/rtu_client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # RTU client implementation
   # @example
@@ -7,16 +9,34 @@ module ModBus
   #     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, baud=9600, opts = {})
-      open_serial_port(port, baud, opts)
+    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 ||= 10_002
+        open_tcp_connection(port_or_ipaddr, arg, opts)
+      end
     end
 
     def get_slave(uid, io)

data/lib/rmodbus/rtu_server.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module ModBus
   # RTU server implementation
   # @example
-  #   srv = RTUServer.new('/dev/ttyS1', 9600, 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 = 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.logger = Logger.new($stdout)
   #   srv.start
   class RTUServer
     include Debug
@@ -17,18 +20,19 @@ module ModBus
     # Init RTU server
     # @param [Integer] uid slave device
     # @see SP#open_serial_port
-    def initialize(port, baud=9600, uid=1, opts = {})
+    def initialize(port, baud = 9600, opts = {})
       Thread.abort_on_exception = true
-      @sp = open_serial_port(port, baud, opts)
-      @uid = uid
+      @sp = if port.is_a?(IO) || port.respond_to?(:read)
+              port
+            else
+              open_serial_port(port, baud, opts)
+            end
     end
 
     # Start server
     def start
       @serv = Thread.new do
-        serv_rtu_requests(@sp) do |msg|
-          exec_req(msg[1..-3], @coils, @discrete_inputs, @holding_registers, @input_registers)
-        end
+        serve(@sp)
       end
     end
 

data/lib/rmodbus/rtu_slave.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModBus
   # RTU slave implementation
   # @example
@@ -10,20 +12,41 @@ module ModBus
   # @see RTUClient#open_connection
   # @see Client#with_slave
   # @see Slave
-  class RTUSlave < Slave
+  class RTUSlave < Client::Slave
     include RTU
 
     private
+
     # overide method for RTU implamentaion
     # @see Slave#query
     def send_pdu(pdu)
-      send_rtu_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
-      read_rtu_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].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
+        sleep(0.1)
+      end
     end
   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
@@ -7,12 +9,13 @@ end
 module ModBus
   # RTU over TCP server implementation
   # @example
-  #   srv = RTUViaTCPServer.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 = 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.logger = Logger.new($stdout)
   #   srv.start
   class RTUViaTCPServer < GServer
     include Debug
@@ -25,20 +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, uid = 1, opts = {})
-			@uid = uid
+    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
-
-    protected
-    # Serve requests
-    # @param [TCPSocket] io socket
-    def serve(io)
-      serv_rtu_requests(io) do |msg|
-        exec_req(msg[1..-3], @coils, @discrete_inputs, @holding_registers, @input_registers)
-      end
+      super(port, opts[:host], opts[:max_connection])
     end
   end
 end

data/lib/rmodbus/server/slave.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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