rmodbus 0.4.0 → 0.5.0

data/AUTHORS

@@ -1,2 +1,3 @@
 Timin Aleksey
 James Sanders
+Kelley Reynolds

data/ChangeLog

@@ -54,3 +54,29 @@
 	SerialPort::NONE, SerialPort::EVEN, SerialPort::ODD
 2010-01-20 Timin Aleksey <atimin@gmail.com>
 	* lib/rmodbus/ext.rb: Fixed bug for	divisible 8 data in Array#pack_to_word 
+2010-02-6 Timin Aleksey <atimin@gmail.com>
+	* lib/rmodbus/client.rb, lib/rmodbus/tcp_client.rb:	Client#connection_retries don't use more 
+2010-07-16 Timin Aleksey <atimin@gmail.com>
+	* lib/rmodbus/rtu_client.rb: Added option read_timeout and accessor RTUClient#read_timeout
+2010-07-28 Kelley Reynolds <kelley@insidesystems.net>
+	* lib/rmodbus/rtu_via_tcp_client.rb: Added the ability to send RTU commands via TCP Serial Gateway
+2010-07-31 Kelley Reynolds <kelley@insidesystems.net>
+	* examples/use_rtu_via_tcp_modbus.rb: Added example for using RTUViaTCP client and server
+	* examples/use_tcp_modbus.rb: Misc cleanups
+	* lib/rmodbus.rb: Include the RTUViaTCPServer and Common files
+	* lib/rmodbus/client.rb: Move logging to Common
+	* lib/rmodbus/common.rb: File which houses common logging methods
+	* lib/rmodbus/rtu_client.rb: Logging updates
+	* lib/rmodbus/rtu_via_tcp_client.rb: Added RTUViaTCPClient#read_modbus_rtu_response() to abstract reading the correct number of bytes for RTU via TCP
+	* lib/rmodbus/rtu_via_tcp_server.rb: Added RTUViaTCPServer for use with testing RTUViaTCPClient
+	* lib/rmodbus/tcp_client.rb: Logging updates
+	* lib/rmodbus/tcp_server.rb: Logging updates
+	* spec/logging_spec.rb: Updated to new logging
+2011-02-02 Timin Aleksey <atimin@gmail> 
+    * lib/rmodbus/client.rb, lib/rmodbus/rtu_client.rb : Remove RTUViaTCPClient#read_mb_rtu_response -> Client#read_rtu_response. Added support for exception and mask sunction.
+	* lib/rmodbus/rtu_client.rb : use #read_rtu_response for read pdu 
+	* spec/read_rtu_response_spec.rb : add test for Client#read_rtu_response method
+	* spec/rtu_via_tcp_client_spec.rb : add test for RTUViaTCP class
+2011-02-10 Timin Aleksey <atimin@gmail.com>
+    * lib/rmodbus/client.rb : Fixed retry of request after end timeout. Added property #read_retry_timeout.
+    * rmodbus.gemspec : New 0.5.0 release 

data/README

@@ -5,7 +5,7 @@
 == Features
 
 * Support Ruby 1.8, Ruby 1.9
-* Support ModBus-TCP, ModBus-RTU protocol
+* Support TCP, RTU, RTU over TCP protocols
 * Support client(master) and server(slave)
 * Support functions:
   * 01 (0x01) Read Coils
@@ -28,11 +28,13 @@ $ gem install --remote rmodbus
 
 require 'rmodbus'
 
-cl = ModBus::TCPClient.new('127.0.0.1', 8502, 1)
+cl = ModBus::TCPClient.new('127.0.0.1', 8502, 1) do |cl|
 
-puts cl.read_holding_registers(0,4)
+  puts cl.read_holding_registers(0,4)
 
-cl.write_multiple_registers(0, [4,4,4])
+  cl.write_multiple_registers(0, [4,4,4])
+
+end
 
 == GitHub 
 

data/examples/use_rtu_via_tcp_modbus.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib/')
+require 'rmodbus'
+
+srv = ModBus::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.start
+
+ModBus::RTUViaTCPClient.connect('127.0.0.1', 10002, 1) do |cl|
+	cl.debug = true
+	puts cl.read_holding_registers(0,4).inspect
+	cl.write_multiple_registers(0, [4,4,4])
+	puts cl.read_holding_registers(0,4).inspect
+end
+
+srv.shutdown

data/examples/use_tcp_modbus.rb

@@ -10,9 +10,10 @@ srv.debug = true
 srv.audit = true
 srv.start
 
-cl = ModBus::TCPClient.new('127.0.0.1', 8502, 1)
-cl.debug = true
-puts cl.read_holding_registers(0,4)
-cl.write_multiple_registers(0, [4,4,4])
-puts cl.read_holding_registers(0,4)
+ModBus::TCPClient.connect('127.0.0.1', 8502, 1) do |cl|
+	cl.debug = true
+	puts cl.read_holding_registers(0,4)
+	cl.write_multiple_registers(0, [4,4,4])
+	puts cl.read_holding_registers(0,4)
+end
 srv.stop

data/lib/rmodbus.rb

@@ -9,8 +9,11 @@
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
+require 'rmodbus/common'
 require 'rmodbus/tcp_client'
 require 'rmodbus/tcp_server'
 require 'rmodbus/rtu_client'
 require 'rmodbus/rtu_server'
+require 'rmodbus/rtu_via_tcp_client'
+require 'rmodbus/rtu_via_tcp_server'
 

data/lib/rmodbus/client.rb

@@ -12,21 +12,42 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 
+require 'rmodbus/common'
 require 'rmodbus/exceptions'
 require 'rmodbus/ext'
 
 
 module ModBus
-
   class Client
-  
     include Errors
+    include Common
     # Number of times to retry on connection and read timeouts
-    attr_accessor :connection_retries, :read_retries
+    attr_accessor :read_retries, :read_retry_timeout
+
+    def connection_retries
+      warn "[DEPRECATION] `connection_retries` is deprecated.  Please don't use it."
+      @connection_retries
+    end
 
+    def connection_retries=(value)
+      warn "[DEPRECATION] `connection_retries=` is deprecated.  Please don't use it."
+      @connection_retries = value
+    end
+
+
+    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")
+    }
     def initialize
       @connection_retries = 10
       @read_retries = 10
+      @read_retry_timeout = 1
     end
     # Read value *ncoils* coils starting with *addr*
     #
@@ -44,7 +65,7 @@ module ModBus
 
     # Deprecated version of read_discrete_inputs
     def read_discret_inputs(addr, ncoils)
-      warn "[DEPRECATION] `read_discret_inputs` is deprecated.  Please use `read_discrete_inputs` instead."
+      #warn "[DEPRECATION] `read_discret_inputs` is deprecated.  Please use `read_discrete_inputs` instead."
       read_discrete_inputs(addr, ncoils)
     end
 
@@ -131,12 +152,14 @@ module ModBus
     end
 
     def query(pdu)    
-      send_pdu(pdu)
-
       tried = 0
       begin
-        timeout(1, ModBusTimeout) { pdu = read_pdu }
+        timeout(@read_retry_timeout, ModBusTimeout) do 
+          send_pdu(pdu)
+          pdu = read_pdu
+        end
       rescue ModBusTimeout => err
+        log "Timeout of read operation: (#{@read_retries - tried})"
         tried += 1
         retry unless tried >= @read_retries
         raise ModBusTimeout.new, "Timed out during read attempt"
@@ -145,29 +168,16 @@ module ModBus
       return nil if pdu.size == 0
 
       if pdu.getbyte(0) >= 0x80
-        case pdu.getbyte(1)
-          when 1
-            raise IllegalFunction.new, "The function code received in the query is not an allowable action for the server"  
-          when 2
-            raise IllegalDataAddress.new, "The data address received in the query is not an allowable address for the server"
-          when 3
-            raise IllegalDataValue.new, "A value contained in the query data field is not an allowable value for server"
-          when 4
-            raise SlaveDeviceFailure.new, "An unrecoverable error occurred while the server was attempting to perform the requested action"
-          when 5
-            raise Acknowledge.new, "The server has accepted the request and is processing it, but a long duration of time will be required to do so"
-          when 6
-            raise SlaveDeviceBus.new, "The server is engaged in processing a long duration program command"
-          when 8
-            raise MemoryParityError.new, "The extended file area failed to pass a consistency check"
-          else
-            raise ModBusException.new, "Unknown error"
-        end
+        exc_id = pdu.getbyte(1)
+        raise Exceptions[exc_id] unless Exceptions[exc_id].nil?
+
+        raise ModBusException.new, "Unknown error"
       end
       pdu[2..-1]
     end
 
     protected
+
     def send_pdu(pdu)
     end
 
@@ -177,20 +187,27 @@ module ModBus
     def close
     end
 
-    private
-    def logging_bytes(msg)
-      result = ""
-      msg.each_byte do |c|
-        byte = if c < 16
-          '0' + c.to_s(16)
+	# 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 = io.read(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(4)
         else
-          c.to_s(16)
-        end
-        result << "[#{byte}]"
+          raise ModBus::Errors::IllegalFunction, "Illegal function: #{function_code}"
       end
-      result
     end
-
   end
-
 end

data/lib/rmodbus/common.rb

@@ -0,0 +1,23 @@
+module ModBus
+	module Common
+
+		private
+		def log(msg)
+			$stdout.puts msg if @debug
+		end
+
+		def logging_bytes(msg)
+			result = ""
+			msg.each_byte do |c|
+				byte = if c < 16
+					'0' + c.to_s(16)
+				else
+					c.to_s(16)
+				end
+				result << "[#{byte}]"
+			end
+			result
+		end
+	end
+end
+

data/lib/rmodbus/ext.rb

@@ -22,8 +22,8 @@ class String
 
   def unpack_bits
     array_bit = []
-    self.unpack('b*')[0].each_byte do |b|
-        array_bit << b.chr.to_i
+    self.unpack('b*')[0].each_char do |c|
+        array_bit << c.to_i
     end
     array_bit
   end

data/lib/rmodbus/rtu_client.rb

@@ -24,7 +24,7 @@ module ModBus
   class RTUClient < Client
 
     include CRC16
-    attr_reader :port, :baud, :slave, :data_bits, :stop_bits, :parity
+    attr_reader :port, :baud, :slave, :data_bits, :stop_bits, :parity, :read_timeout
     attr_accessor :debug
 
     # Connect with RTU server
@@ -81,19 +81,22 @@ module ModBus
     # :stop_bits => 1 or 2
     #
     # :parity => NONE, EVEN or ODD
+    #
+    # :read_timeout => default 5 ms
     def initialize(port, baud=9600, slaveaddr=1, options = {})
       @port, @baud, @slave = port, baud, slaveaddr
       
-      @data_bits, @stop_bits, @parity = 8, 1, SerialPort::NONE
+      @data_bits, @stop_bits, @parity, @read_timeout = 8, 1, SerialPort::NONE, 5
 
       @data_bits = options[:data_bits] unless options[:data_bits].nil?
       @stop_bits = options[:stop_bits] unless options[:stop_bits].nil?
       @parity = options[:parity] unless options[:parity].nil?
+      @read_timeout = options[:read_timeout] unless options[:read_timeout].nil?
 
       @debug = false
 
       @sp = SerialPort.new(@port, @baud, @data_bits, @stop_bits, @parity)
-      @sp.read_timeout = 5
+      @sp.read_timeout = @read_timeout
 
       super()
     end
@@ -111,23 +114,20 @@ module ModBus
       msg = @slave.chr + pdu 
       msg << crc16(msg).to_word
       @sp.write msg
-      if @debug
-        STDOUT << "Tx (#{msg.size} bytes): " + logging_bytes(msg) + "\n"
-      end
+
+      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
     end
 
     def read_pdu
-      msg = ''
-      while msg.size == 0
-        msg =  @sp.read
-      end
+	  msg = read_rtu_response(@sp)
 
-      if @debug
-        STDOUT << "Rx (#{msg.size} bytes): " + logging_bytes(msg) + "\n"
-      end
+      log "Rx (#{msg.size} bytes): " + logging_bytes(msg)
 
       if msg.getbyte(0) == @slave
         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 slave ID"
       end
       loop do
         #waite timeout  

data/lib/rmodbus/rtu_via_tcp_client.rb

@@ -0,0 +1,105 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2009  Timin Aleksey
+# Copyright (C) 2010  Kelley Reynolds
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+require 'rmodbus/crc16'
+require 'timeout'
+require 'rmodbus/client'
+require 'rmodbus/exceptions'
+
+module ModBus
+  
+  class RTUViaTCPClient < Client
+
+		include CRC16
+		attr_reader :ipaddr, :port, :slave
+		attr_accessor :debug
+
+		# Connect with Serial TCP Gateway (eg barionet-50)
+		#
+		# ipaddr - ip of the server
+		#
+		# port - port TCP connections
+		#
+		# slaveaddr - slave ID of the server
+		#
+		# RTUViaTCPClient.connect('127.0.0.1') do |cl|
+		#
+		#   put cl.read_holding_registers(0, 10)
+		#
+		# end
+		def self.connect(ipaddr, port = 10002, slaveaddr = 1)
+			cl = RTUViaTCPClient.new(ipaddr, port, slaveaddr) 
+			yield cl
+			cl.close
+		end
+
+		# Connect with a ModBus server
+		#
+		# ipaddr - ip of the server
+		#
+		# port - port TCP connections
+		#
+		# slaveaddr - slave ID of the server
+		def initialize(ipaddr, port = 10002, slaveaddr = 1)
+			@ipaddr, @port = ipaddr, port
+			tried = 0
+			begin
+				timeout(1, ModBusTimeout) do
+					@sock = TCPSocket.new(@ipaddr, @port)
+				end
+			rescue ModBusTimeout => err
+				raise ModBusTimeout.new, 'Timed out attempting to create connection'
+			end
+			@slave = slaveaddr
+			@debug = false
+			super()
+		end
+
+		# Close TCP connections
+		def close
+			@sock.close unless @sock.closed?
+		end
+
+		# Check TCP connections
+		def closed?
+			@sock.closed?
+		end
+
+		protected
+
+		def send_pdu(pdu)
+			msg = @slave.chr + pdu 
+			msg << crc16(msg).to_word
+			@sock.write msg
+
+			log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+		end
+
+		def read_pdu
+			# Read the response appropriately
+			msg = read_rtu_response(@sock)
+
+			log "Rx (#{msg.size} bytes): " + logging_bytes(msg)
+			if msg.getbyte(0) == @slave
+				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 slave ID"
+			end
+			loop do
+				#waite timeout  
+			end
+		end
+	end
+end

data/lib/rmodbus/rtu_via_tcp_server.rb

@@ -0,0 +1,114 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2010  Timin Aleksey
+# Copyright (C) 2010  Kelley Reynolds
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+require 'rmodbus/parsers'
+require 'gserver'
+
+module ModBus
+ 
+	class RTUViaTCPServer < GServer
+		include Parsers
+		include CRC16
+		include Common
+		
+		attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers, :debug
+
+		def discret_inputs
+			warn "[DEPRECATION] `discret_inputs` is deprecated.  Please use `discrete_inputs` instead."
+			@discrete_inputs 
+		end
+
+		def discret_inputs=(val)
+			warn "[DEPRECATION] `discret_inputs=` is deprecated.  Please use `discrete_inputs=` instead."
+			@discrete_inputs=val
+		end
+
+
+		def initialize(port = 10002, slave = 1)
+			@coils = []
+			@discrete_inputs = []
+			@holding_registers =[]
+			@input_registers = []
+			@slave = slave
+			super(port)
+		end
+
+		def serve(io)
+			loop do
+				# read the RTU message
+				msg = read_modbus_rtu_request(io)
+				
+				# If there is no RTU message, we're done serving this client
+				break if msg.nil?
+				
+				if msg.getbyte(0) == @slave and msg[-2,2].unpack('n')[0] == crc16(msg[0..-3])
+					pdu = exec_req(msg[1..-3], @coils, @discrete_inputs, @holding_registers, @input_registers)
+					resp = @slave.chr + pdu
+					resp << crc16(resp).to_word
+					log "Server TX (#{resp.size} bytes): #{logging_bytes(resp)}"
+					io.write resp
+				end
+			end
+		end
+		
+		private
+		
+		# We have to read specific amounts of numbers of bytes from the network depending on the function code and content
+		# NOTE: The initial read could be increased to 7 and that would let us cobine the two reads for functions 15 and 16 but this method is more clear
+		def read_modbus_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 log(msg)
+			if @debug
+				$stdout.puts msg
+			end
+		end
+
+		def logging_bytes(msg)
+			result = ""
+			msg.each_byte do |c|
+				byte = if c < 16
+					'0' + c.to_s(16)
+				else
+					c.to_s(16)
+				end
+				result << "[#{byte}]"
+			end
+			result
+		end
+	end
+end

data/lib/rmodbus/tcp_client.rb

@@ -23,10 +23,8 @@ module ModBus
 
     include Timeout
 
-    attr_reader :ipaddr, :port, :slave
+    attr_reader :ipaddr, :port, :slave, :transaction
     attr_accessor :debug
-
-    @@transaction = 0
     
     # Connect with ModBus server
     #
@@ -55,15 +53,14 @@ module ModBus
     #
     # slaveaddr - slave ID of the server
     def initialize(ipaddr, port = 502, slaveaddr = 1)
+      @transaction = 0
       @ipaddr, @port = ipaddr, port
       tried = 0
       begin
         timeout(1, ModBusTimeout) do
-        @sock = TCPSocket.new(@ipaddr, @port)
-      end
+          @sock = TCPSocket.new(@ipaddr, @port)
+        end
       rescue ModBusTimeout => err
-        tried += 1
-        retry unless tried >= @connection_retries 
         raise ModBusTimeout.new, 'Timed out attempting to create connection'
       end
       @slave = slaveaddr
@@ -81,32 +78,25 @@ module ModBus
       @sock.closed?
     end
 
-    def self.transaction 
-      @@transaction
-    end
-
     private
     def send_pdu(pdu)   
-      @@transaction = 0 if @@transaction.next > 65535
-      @@transaction += 1 
-      msg = @@transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @slave.chr + pdu
+      @transaction = 0 if @transaction.next > 65535
+      @transaction += 1 
+      msg = @transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @slave.chr + pdu
       @sock.write msg
       
-      if debug
-        STDOUT << "Tx (#{msg.size} bytes): " + logging_bytes(msg) + "\n"
-      end
+      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
     end
 
     def read_pdu    
       header = @sock.read(7)            
       if header
         tin = header[0,2].unpack('n')[0]
-        raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @@transaction
+        raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @transaction
         len = header[4,2].unpack('n')[0]       
         msg = @sock.read(len-1)               
-        if @debug
-          STDOUT << "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg) + "\n"
-        end
+
+        log "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg)
         msg
       else
         raise Errors::ModBusException.new("Server did not respond")

data/lib/rmodbus/tcp_server.rb

@@ -14,49 +14,51 @@
 require 'rmodbus/parsers'
 require 'gserver'
 
-
 module ModBus
-  class TCPServer < GServer
-    include Parsers
-    
-    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers
-
-    def discret_inputs
-      warn "[DEPRECATION] `discret_inputs` is deprecated.  Please use `discrete_inputs` instead."
-      @discrete_inputs 
-    end
-  
-    def discret_inputs=(val)
-      warn "[DEPRECATION] `discret_inputs=` is deprecated.  Please use `discrete_inputs=` instead."
-      @discrete_inputs=val
-    end
-  
-   
-    def initialize(port = 502, uid = 1)
-      @coils = []
-      @discrete_inputs = []
-      @holding_registers =[]
-      @input_registers = []
-      @uid = uid
-      super(port)
-    end
-
-    def serve(io)
-      loop do
-        req = io.read(7)
-        if req[2,2] != "\x00\x00" or req.getbyte(6) != @uid
-          io.close
-          break
-        end
- 
-        tr = req[0,2]
-        len = req[4,2].unpack('n')[0]
-        req = io.read(len - 1)
-
-        pdu = exec_req(req, @coils, @discrete_inputs, @holding_registers, @input_registers)
-
-        io.write tr + "\0\0" + (pdu.size + 1).to_word + @uid.chr + pdu
-    end
-    end
-  end
+	class TCPServer < GServer
+		include Parsers
+		include Common
+
+		attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers, :debug
+
+		def discret_inputs
+			warn "[DEPRECATION] `discret_inputs` is deprecated.  Please use `discrete_inputs` instead."
+			@discrete_inputs 
+		end
+
+		def discret_inputs=(val)
+			warn "[DEPRECATION] `discret_inputs=` is deprecated.  Please use `discrete_inputs=` instead."
+			@discrete_inputs=val
+		end
+
+		def initialize(port = 502, uid = 1)
+			@coils = []
+			@discrete_inputs = []
+			@holding_registers =[]
+			@input_registers = []
+			@uid = uid
+			super(port)
+		end
+
+		def serve(io)
+			loop do
+				req = io.read(7)
+				if req[2,2] != "\x00\x00" or req.getbyte(6) != @uid
+					io.close
+					break
+				end
+
+				tr = req[0,2]
+				len = req[4,2].unpack('n')[0]
+				req = io.read(len - 1)
+				log "Server RX (#{req.size} bytes): #{logging_bytes(req)}"
+
+				pdu = exec_req(req, @coils, @discrete_inputs, @holding_registers, @input_registers)
+
+				resp = tr + "\0\0" + (pdu.size + 1).to_word + @uid.chr + pdu
+				log "Server TX (#{resp.size} bytes): #{logging_bytes(resp)}"
+				io.write resp
+			end
+		end
+	end
 end

data/spec/ext_spec.rb

@@ -4,6 +4,7 @@ describe Array do
 
   before do
     @arr = [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
+    @test = [0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0]
   end
 
   it "should return string reprisent 16bit" do
@@ -13,6 +14,10 @@ describe Array do
   it "fixed bug for	divisible 8 data " do
     ([0] * 8).pack_to_word.should == "\x00"
   end
+  
+  it "should unpack to @test" do
+    "test".unpack_bits == @test
+  end
 
 end
 

data/spec/logging_spec.rb

@@ -20,8 +20,8 @@ describe TCPClient  do
     request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
     mock_query(request,response)
     @mb_client.debug = true
-    STDOUT.should_receive("<<").with("Tx (12 bytes): [00][01][00][00][00][06][01][03][00][6b][00][03]\n")
-    STDOUT.should_receive("<<").with("Rx (15 bytes): [00][01][00][00][00][09][01][03][06][02][2b][00][00][00][64]\n")
+    $stdout.should_receive(:puts).with("Tx (12 bytes): [00][01][00][00][00][06][01][03][00][6b][00][03]")
+    $stdout.should_receive(:puts).with("Rx (15 bytes): [00][01][00][00][00][09][01][03][06][02][2b][00][00][00][64]")
     @mb_client.query(request)
   end
 
@@ -33,7 +33,7 @@ describe TCPClient  do
 
 
   def mock_query(request, response)
-    @adu = TCPClient.transaction.next.to_word + "\x0\x0\x0\x9" + UID.chr + request
+    @adu = @mb_client.transaction.next.to_word + "\x0\x0\x0\x9" + UID.chr + request
     @sock.should_receive(:write).with(@adu[0,4] + "\0\6" + UID.chr + request)
     @sock.should_receive(:read).with(7).and_return(@adu[0,7])
     @sock.should_receive(:read).with(8).and_return(response)
@@ -56,11 +56,13 @@ describe RTUClient do
   it 'should log rec\send bytes' do
     request = "\x3\x0\x1\x0\x1"
     @sp.should_receive(:write).with("\1#{request}\xd5\xca")
-    @sp.should_receive(:read).and_return("\x1\x3\x2\xff\xff\xb9\xf4")
+    @sp.should_receive(:read).with(2).and_return("\x1\x3")
+    @sp.should_receive(:read).with(1).and_return("\x2")
+    @sp.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
 
     @mb_client.debug = true
-    STDOUT.should_receive("<<").with("Tx (8 bytes): [01][03][00][01][00][01][d5][ca]\n")
-    STDOUT.should_receive("<<").with("Rx (7 bytes): [01][03][02][ff][ff][b9][f4]\n")
+    $stdout.should_receive(:puts).with("Tx (8 bytes): [01][03][00][01][00][01][d5][ca]")
+    $stdout.should_receive(:puts).with("Rx (7 bytes): [01][03][02][ff][ff][b9][f4]")
 
     @mb_client.query(request).should == "\xff\xff"
   end

data/spec/read_rtu_response_spec.rb

@@ -0,0 +1,93 @@
+require 'rmodbus/client'
+
+include ModBus
+
+#Use public wrap method
+
+class Client
+  def test_read_method(msg)
+    io = TestIO.new(msg)
+    read_rtu_response(io)
+  end
+
+end
+
+class TestIO
+  def initialize(msg)
+    @msg = msg
+  end
+
+  def read(num)
+    result = @msg[0,num]
+    @msg = @msg[num..-1]
+    result
+  end
+end
+
+describe "#read_rtu_response" do
+  before do
+    @cl_mb = Client.new   
+  end
+
+  it "should read response for 'read coils'" do
+    resp = make_resp("\x1\x3\xcd\x6b\x05")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'read discrete inputs'" do
+    resp = make_resp("\x2\x3\xac\xdb\x35")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'read holding registers'" do
+    resp = make_resp("\x3\x6\x2\x2b\x0\x0\x0\x64")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'read input registers'" do
+    resp = make_resp("\x4\x2\x0\xa")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write single coil'" do
+    resp = make_resp("\x5\x0\xac\xff\x0")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write single register'" do
+    resp = make_resp("\x6\x0\x1\x0\x3")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write multiple coils'" do
+    resp = make_resp("\xf\x0\x13\x0\xa")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write multiple registers'" do
+    resp = make_resp("\x10\x0\x1\x0\x2")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response 'mask write register'" do
+    resp = make_resp("\x16\x0\x4\x0\xf2\x0\x25")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read exception codes" do
+    resp = make_resp("\x84\x3")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should raise exception if function is illegal" do
+    resp = make_resp("\xff\x0\x1\x0\x2").should raise_error {
+      ModBus::Errors::IllegalFunction
+    }
+  end
+
+
+  def make_resp(msg)
+    "\x1" + msg + "\x2\x2" # slave + msg + mock_crc
+  end
+end
+

data/spec/rtu_client_spec.rb

@@ -12,6 +12,7 @@ describe RTUClient do
     @sp = mock('Serial port')
     SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
     @sp.stub!(:read_timeout=)
+    @sp.stub!(:read)
 
     @mb_client = RTUClient.new("/dev/port1", 9600, 1, 
       :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
@@ -21,21 +22,25 @@ describe RTUClient do
   it "should ignore frame with other UID" do
     request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
     @sp.should_receive(:write).with("\1#{request}\xA6\x31")
-    @sp.should_receive(:read).and_return("\x2\x10\x0\x1\x0\x1\x1C\x08")
+    @sp.should_receive(:read).with(2).and_return("\x2\x10")
+    @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
     lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
   end
 
   it "should ignored frame with incorrect CRC" do
     request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
     @sp.should_receive(:write).with("\1#{request}\xA6\x31")
-    @sp.should_receive(:read).and_return("\x1\x10\x0\x1\x0\x1\x1C\x08")
+    @sp.should_receive(:read).with(2).and_return("\x2\x10")
+    @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
     lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
   end
   
   it "should return value of registers"do
     request = "\x3\x0\x1\x0\x1"
     @sp.should_receive(:write).with("\1#{request}\xd5\xca")
-    @sp.should_receive(:read).and_return("\x1\x3\x2\xff\xff\xb9\xf4")
+    @sp.should_receive(:read).with(2).and_return("\x1\x3")
+    @sp.should_receive(:read).with(1).and_return("\x2")
+    @sp.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
     @mb_client.query(request).should == "\xff\xff"
   end
 

data/spec/rtu_via_tcp_client_spec.rb

@@ -0,0 +1,72 @@
+begin
+  require 'rubygems'
+rescue
+end
+require 'rmodbus'
+
+include ModBus
+
+describe RTUViaTCPClient do
+    
+  before do 
+    @sock = mock('Socked')
+    TCPSocket.should_receive(:new).with("127.0.0.1", 10002).and_return(@sock)    
+    @sock.stub!(:read_timeout=)
+    @sock.stub!(:read)
+
+    @mb_client = RTUViaTCPClient.new("127.0.0.1") 
+    @mb_client.read_retries = 0
+  end
+
+  it "should ignore frame with other UID" do
+    request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
+    @sock.should_receive(:write).with("\1#{request}\xA6\x31")
+    @sock.should_receive(:read).with(2).and_return("\x2\x10")
+    @sock.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
+    lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
+  end
+
+  it "should ignored frame with incorrect CRC" do
+    request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
+    @sock.should_receive(:write).with("\1#{request}\xA6\x31")
+    @sock.should_receive(:read).with(2).and_return("\x2\x10")
+    @sock.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
+    lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
+  end
+  
+  it "should return value of registers"do
+    request = "\x3\x0\x1\x0\x1"
+    @sock.should_receive(:write).with("\1#{request}\xd5\xca")
+    @sock.should_receive(:read).with(2).and_return("\x1\x3")
+    @sock.should_receive(:read).with(1).and_return("\x2")
+    @sock.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
+    @mb_client.query(request).should == "\xff\xff"
+  end
+
+ it 'should sugar connect method' do
+   ipaddr, port, slave = '127.0.0.1', 502, 3
+    TCPSocket.should_receive(:new).with(ipaddr, port).and_return(@sock)
+    @sock.should_receive(:closed?).and_return(false)
+    @sock.should_receive(:close)
+    RTUViaTCPClient.connect(ipaddr, port, slave) do |cl|
+      cl.ipaddr.should == ipaddr
+      cl.port.should == port
+      cl.slave.should == slave
+    end
+  end
+
+  it 'should have closed? method' do
+    @sock.should_receive(:closed?).and_return(false)
+    @mb_client.closed?.should == false
+
+    @sock.should_receive(:closed?).and_return(false)
+    @sock.should_receive(:close)
+
+    @mb_client.close
+
+    @sock.should_receive(:closed?).and_return(true)
+    @mb_client.closed?.should == true
+  end
+
+end
+

data/spec/tcp_client_spec.rb

@@ -17,14 +17,14 @@ describe TCPClient, "method 'query'"  do
   end
 
   it 'should send valid MBAP Header' do
-    @adu[0,2] = TCPClient.transaction.next.to_word
+    @adu[0,2] = @mb_client.transaction.next.to_word
     @sock.should_receive(:write).with(@adu)
     @sock.should_receive(:read).with(7).and_return(@adu)
     @mb_client.query('').should == nil
   end
 
   it 'should throw exception if get other transaction' do
-    @adu[0,2] = TCPClient.transaction.next.to_word
+    @adu[0,2] = @mb_client.transaction.next.to_word
     @sock.should_receive(:write).with(@adu)
     @sock.should_receive(:read).with(7).and_return("\000\002\000\000\000\001" + UID.chr)
     begin
@@ -37,7 +37,7 @@ describe TCPClient, "method 'query'"  do
   it 'should return only data from PDU' do
     request = "\x3\x0\x6b\x0\x3"
     response = "\x3\x6\x2\x2b\x0\x0\x0\x64"
-    @adu = TCPClient.transaction.next.to_word + "\x0\x0\x0\x9" + UID.chr + request
+    @adu = @mb_client.transaction.next.to_word + "\x0\x0\x0\x9" + UID.chr + request
     @sock.should_receive(:write).with(@adu[0,4] + "\0\6" + UID.chr + request)
     @sock.should_receive(:read).with(7).and_return(@adu[0,7])
     @sock.should_receive(:read).with(8).and_return(response)

metadata

@@ -1,27 +1,39 @@
 --- !ruby/object:Gem::Specification 
 name: rmodbus
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
-- A.Timin, J. Sanders
+- A.Timin, J. Sanders, K. Reynolds
 autorequire: rmodbus
 bindir: bin
 cert_chain: []
 
-date: 2010-01-23 00:00:00 +05:00
+date: 2011-02-10 00:00:00 +05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: serialport
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.1
-    version: 
+        hash: 31
+        segments: 
+        - 1
+        - 0
+        - 4
+        version: 1.0.4
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: atimin@gmail.com
 executables: []
@@ -34,28 +46,34 @@ extra_rdoc_files:
 - LICENSE
 - ChangeLog
 files: 
-- lib/rmodbus/tcp_client.rb
+- lib/rmodbus.rb
+- lib/rmodbus/client.rb
+- lib/rmodbus/crc16.rb
 - lib/rmodbus/parsers.rb
 - lib/rmodbus/rtu_client.rb
+- lib/rmodbus/ext.rb
+- lib/rmodbus/rtu_via_tcp_client.rb
 - lib/rmodbus/tcp_server.rb
-- lib/rmodbus/rtu_server.rb
 - lib/rmodbus/exceptions.rb
-- lib/rmodbus/client.rb
-- lib/rmodbus/ext.rb
-- lib/rmodbus/crc16.rb
-- lib/rmodbus.rb
+- lib/rmodbus/rtu_server.rb
+- lib/rmodbus/rtu_via_tcp_server.rb
+- lib/rmodbus/common.rb
+- lib/rmodbus/tcp_client.rb
+- examples/add_new_function.rb
 - examples/use_tcp_modbus.rb
-- examples/perfomance_rtu.rb
 - examples/perfomance_tcp.rb
-- examples/add_new_function.rb
-- spec/logging_spec.rb
+- examples/use_rtu_via_tcp_modbus.rb
+- examples/perfomance_rtu.rb
 - spec/ext_spec.rb
-- spec/tcp_client_spec.rb
-- spec/rtu_client_spec.rb
 - spec/exception_spec.rb
-- spec/client_spec.rb
 - spec/tcp_server_spec.rb
+- spec/logging_spec.rb
+- spec/client_spec.rb
 - spec/rtu_server_spec.rb
+- spec/tcp_client_spec.rb
+- spec/rtu_via_tcp_client_spec.rb
+- spec/read_rtu_response_spec.rb
+- spec/rtu_client_spec.rb
 - Rakefile
 - README
 - AUTHORS
@@ -75,21 +93,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: RModBus
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: RModBus - free implementation of protocol ModBus