rmodbus 0.5.0 → 1.0.0

data/lib/rmodbus/rtu_server.rb

@@ -1,6 +1,6 @@
 # RModBus - free implementation of ModBus protocol in Ruby.
 #
-# Copyright (C) 2010  Timin Aleksey
+# Copyright (C) 2010-2011 Timin Aleksey
 #
 # 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
@@ -11,78 +11,49 @@
 # 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'
-
-begin
-  require 'rubygems'
-rescue
-end
-
 require 'serialport'
 
 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.start
   class RTUServer
-    include Parsers
-    include CRC16
-
-    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers
-    attr_reader :port, :baud, :slave, :data_bits, :stop_bits, :parity
-
-     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, baud=9600, slaveaddr=1, options = {})
-      Thread.abort_on_exception = true 
-
-      @port, @baud = port, baud
-      @data_bits, @stop_bits, @parity = 8, 1, SerialPort::NONE
-
-      @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?
-
-      @sp = SerialPort.new(@port, @baud, @data_bits, @stop_bits, @parity)
-      @sp.read_timeout = 5
-
-      @coils = []
-      @discrete_inputs = []
-      @holding_registers = []
-      @input_registers = []
-      @slave = slaveaddr
+    include Common
+    include Server
+    include RTU
+    include SP
+
+    # Init RTU server
+    # @param [Integer] uid slave device
+    # @see SP#open_serial_port
+    def initialize(port, baud=9600, uid=1, opts = {})
+      Thread.abort_on_exception = true
+      @sp = open_serial_port(port, baud, opts)
+      @uid = uid
     end
 
+    # Start server
     def start
       @serv = Thread.new do
-        loop do
-          req = '' 
-          while req.size == 0 
-            req = @sp.read
-          end
-          if req.getbyte(0) == @slave and req[-2,2].unpack('n')[0] == crc16(req[0..-3])
-            pdu = exec_req(req[1..-1], @coils, @discrete_inputs, @holding_registers, @input_registers)
-            resp = @slave.chr + pdu
-            resp << crc16(resp).to_word
-            @sp.write resp
-          end
+        serv_rtu_requests(@sp) do |msg|
+          exec_req(msg[1..-3], @coils, @discrete_inputs, @holding_registers, @input_registers)
         end
       end
     end
 
+    # Stop server
     def stop
       Thread.kill(@serv)
-      @sp.close 
+      @sp.close
     end
 
+    # Join server
     def join
       @serv.join
     end

data/lib/rmodbus/rtu_slave.rb

@@ -0,0 +1,59 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2011  Timin Aleksey
+#
+# 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.
+module ModBus
+  # RTU slave implementation
+  # @example
+  #   RTUClient.connect(port, baud, opts) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUClient#open_connection
+  # @see Client#with_slave
+  # @see Slave
+  class RTUSlave < Slave
+    include RTU
+
+    protected
+
+    # overide method for RTU implamentaion
+    # @see Slave#query
+    def send_pdu(pdu)
+      msg = @uid.chr + pdu
+      msg << crc16(msg).to_word
+      @io.write msg
+
+      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+    end
+
+    # overide method for RTU implamentaion
+    # @see Slave#query
+    def read_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].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
+      end
+    end
+  end
+end

data/lib/rmodbus/rtu_via_tcp_client.rb

@@ -1,6 +1,6 @@
 # RModBus - free implementation of ModBus protocol in Ruby.
 #
-# Copyright (C) 2009  Timin Aleksey
+# Copyright (C) 2009-2011  Timin Aleksey
 # Copyright (C) 2010  Kelley Reynolds
 #
 # This program is free software: you can redistribute it and/or modify
@@ -12,94 +12,30 @@
 # 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
-  
+  # RTU over TCP client implementation
+  # @example
+  #   RTUViaTCPClient.connect('127.0.0.1', 10002) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUViaTCPClient#open_connection
+  # @see Client#initialize
   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?
+		include RTU
+		include TCP
+
+    protected
+		# Open TCP\IP connection
+    # @see TCP#open_tcp_connection
+    def open_connection(ipaddr, port = 10002, opts = {})
+      io = open_tcp_connection(ipaddr, port, opts)
 		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
+    def get_slave(uid, io)
+      RTUViaTCPSlave.new(uid, io)
+    end
 	end
 end

data/lib/rmodbus/rtu_via_tcp_server.rb

@@ -13,102 +13,38 @@
 # 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
+  # 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.start
+  class RTUViaTCPServer < GServer
+    include Common
+    include RTU
+    include Server
+
+    # Init server
+    # @param [Integer] port listen port
+    # @param [Integer] uid slave device
+    def initialize(port = 10002, uid = 1)
+      @uid = uid
+      super(port)
+    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
+    end
+  end
 end

data/lib/rmodbus/rtu_via_tcp_slave.rb

@@ -0,0 +1,58 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2011  Timin Aleksey
+#
+# 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.
+module ModBus
+  # RTU over TCP slave implementation
+  # @example
+  #   RTUViaTCP.connect('127.0.0.1', 10002) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUViaTCPClient#open_connection
+  # @see Client#with_slave
+  # @see Slave
+  class RTUViaTCPSlave < Slave
+		include RTU
+
+		protected
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+		def send_pdu(pdu)
+			msg = @uid.chr + pdu
+			msg << crc16(msg).to_word
+			@io.write msg
+
+			log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+		end
+
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+		def read_pdu
+			# Read the response appropriately
+			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].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
+			end
+		end
+	end
+end

data/lib/rmodbus/{parsers.rb → server.rb}

@@ -1,6 +1,7 @@
-# RModBus - free implementation of ModBus protocol in purge Ruby.
+# 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
@@ -13,17 +14,25 @@
 # GNU General Public License for more details.
 
 module ModBus
-  module Parsers
-
+  # Module for implementation ModBus server
+  module Server
     Funcs = [1,2,3,4,5,6,15,16]
 
+    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers, :uid
+    @coils = []
+    @discrete_inputs = []
+    @holding_registers =[]
+    @input_registers = []
+
+    private
+
     def exec_req(req, coils, discrete_inputs, holding_registers, input_registers)
       func = req.getbyte(0)
-        
+
       unless Funcs.include?(func)
         params = { :err => 1 }
       end
-        
+
       case func
         when 1
           params = parse_read_func(req, coils)
@@ -47,7 +56,7 @@ module ModBus
           if params[:err] == 0
             pdu = func.chr + (params[:quant] * 2).chr + input_registers[params[:addr],params[:quant]].pack('n*')
           end
-        when 5 
+        when 5
           params = parse_write_coil_func(req)
           if params[:err] == 0
             coils[params[:addr]] = params[:val]
@@ -72,24 +81,23 @@ module ModBus
             pdu = req[0,5]
           end
       end
-      
+
       if params[:err] == 0
-        pdu 
+        pdu
       else
         pdu = (func | 0x80).chr + params[:err].chr
       end
     end
 
-    private
     def parse_read_func(req, field)
       quant = req[3,2].unpack('n')[0]
 
       return { :err => 3} unless quant <= 0x7d
-        
+
       addr = req[1,2].unpack('n')[0]
       return { :err => 2 } unless addr + quant <= field.size
-        
-      return { :err => 0, :quant => quant, :addr => addr }    
+
+      return { :err => 0, :quant => quant, :addr => addr }
     end
 
     def parse_write_coil_func(req)
@@ -98,9 +106,9 @@ module ModBus
 
       val = req[3,2].unpack('n')[0]
       return { :err => 3 } unless val == 0 or val == 0xff00
-      
+
       val = 1 if val == 0xff00
-      return { :err => 0, :addr => addr, :val => val }  
+      return { :err => 0, :addr => addr, :val => val }
     end
 
     def parse_write_register_func(req)
@@ -109,7 +117,7 @@ module ModBus
 
       val = req[3,2].unpack('n')[0]
 
-      return { :err => 0, :addr => addr, :val => val }  
+      return { :err => 0, :addr => addr, :val => val }
 	  end
 
     def parse_write_multiple_coils_func(req)
@@ -129,5 +137,6 @@ module ModBus
       end
       params
     end
+
   end
 end