rmodbus 0.5.0 → 1.0.0

data/lib/rmodbus/slave.rb

@@ -0,0 +1,268 @@
+# RModBus - free implementation of ModBus protocol on Ruby.
+#
+# Copyright (C) 2008-2011  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.
+
+module ModBus
+  class Slave
+    include Errors
+  	include Common
+    # Number of times to retry on read and read timeouts
+    attr_accessor :read_retries, :read_retry_timeout, :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")
+    }
+    def initialize(uid, io)
+	    @uid = uid
+      @read_retries = 10
+      @read_retry_timeout = 1
+      @io = io
+    end
+
+    # Returns a ModBus::ReadWriteProxy hash interface for coils
+    #
+    # @example
+    #  coils[addr] => [1]
+    #  coils[addr1..addr2] => [1, 0, ..]
+    #  coils[addr] = 0 => [0]
+    #  coils[addr1..addr2] = [1, 0, ..] => [1, 0, ..]
+    #
+    # @return [ReadWriteProxy] proxy object
+    def coils
+      ModBus::ReadWriteProxy.new(self, :coil)
+    end
+
+    # Read coils
+    #
+    # @example
+    #  read_coils(addr, ncoils) => [1, 0, ..]
+    #
+    # @param [Integer] addr address first coil
+    # @param [Integer] ncoils number coils
+    # @return [Array] coils
+    def read_coils(addr, ncoils)
+      query("\x1" + addr.to_word + ncoils.to_word).unpack_bits[0..ncoils-1]
+    end
+    alias_method :read_coil, :read_coils
+
+    # Write a single coil
+    #
+    # @example
+    #  write_single_coil(1, 0) => self
+    #
+    # @param [Integer] addr address coil
+    # @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)
+      else
+        query("\x5" + addr.to_word + 0xff00.to_word)
+      end
+      self
+    end
+    alias_method :write_coil, :write_single_coil
+
+    # Write multiple coils
+    #
+    # @example
+    #  write_multiple_coils(1, [0,1,0,1]) => self
+    #
+    # @param [Integer] addr address first coil
+    # @param [Array] vals written coils
+    def write_multiple_coils(addr, vals)
+      nbyte = ((vals.size-1) >> 3) + 1
+      sum = 0
+      (vals.size - 1).downto(0) do |i|
+        sum = sum << 1
+        sum |= 1 if vals[i] > 0
+      end
+
+      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)
+      self
+    end
+    alias_method :write_coils, :write_multiple_coils
+
+    # Returns a ModBus::ReadOnlyProxy hash interface for discrete inputs
+    #
+    # @example
+    #  discrete_inputs[addr] => [1]
+    #  discrete_inputs[addr1..addr2] => [1, 0, ..]
+    #
+    # @return [ReadOnlyProxy] proxy object
+    def discrete_inputs
+      ModBus::ReadOnlyProxy.new(self, :discrete_input)
+    end
+
+    # Read discrete inputs
+    #
+    # @example
+    #  read_discrete_inputs(addr, ninputs) => [1, 0, ..]
+    #
+    # @param [Integer] addr address first input
+    # @param[Integer] ninputs number inputs
+    # @return [Array] inputs
+    def read_discrete_inputs(addr, ninputs)
+      query("\x2" + addr.to_word + ninputs.to_word).unpack_bits[0..ninputs-1]
+    end
+    alias_method :read_discrete_input, :read_discrete_inputs
+
+    # Returns a read/write ModBus::ReadOnlyProxy hash interface for coils
+    #
+    # @example
+    #  input_registers[addr] => [1]
+    #  input_registers[addr1..addr2] => [1, 0, ..]
+    #
+    # @return [ReadOnlyProxy] proxy object
+    def input_registers
+      ModBus::ReadOnlyProxy.new(self, :input_register)
+    end
+
+    # Read input registers
+    #
+    # @example
+    #  read_input_registers(1, 5) => [1, 0, ..]
+    #
+    # @param [Integer] addr address first registers
+    # @param [Integer] nregs number registers
+    # @return [Array] registers
+    def read_input_registers(addr, nregs)
+      query("\x4" + addr.to_word + nregs.to_word).unpack('n*')
+    end
+    alias_method :read_input_register, :read_input_registers
+
+    # Returns a ModBus::ReadWriteProxy hash interface for holding registers
+    #
+    # @example
+    #  holding_registers[addr] => [123]
+    #  holding_registers[addr1..addr2] => [123, 234, ..]
+    #  holding_registers[addr] = 123 => 123
+    #  holding_registers[addr1..addr2] = [234, 345, ..] => [234, 345, ..]
+    #
+    # @return [ReadWriteProxy] proxy object
+    def holding_registers
+      ModBus::ReadWriteProxy.new(self, :holding_register)
+    end
+
+    # Read holding registers
+    #
+    # @example
+    #  read_holding_registers(1, 5) => [1, 0, ..]
+    #
+    # @param [Integer] addr address first registers
+    # @param [Integer] nregs number registers
+    # @return [Array] registers
+    def read_holding_registers(addr, nregs)
+      query("\x3" + addr.to_word + nregs.to_word).unpack('n*')
+    end
+    alias_method :read_holding_register, :read_holding_registers
+
+    # Write a single holding register
+    #
+    # @example
+    #  write_single_register(1, 0xaa) => self
+    #
+    # @param [Integer] addr address registers
+    # @param [Integer] val written to register
+    # @return self
+    def write_single_register(addr, val)
+      query("\x6" + addr.to_word + val.to_word)
+      self
+    end
+    alias_method :write_holding_register, :write_single_register
+
+
+    # Write multiple holding registers
+    #
+    # @example
+    #  write_multiple_registers(1, [0xaa, 0]) => self
+    #
+    # @param [Integer] addr address first registers
+    # @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
+
+      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
+
+    # Mask a holding register
+    #
+    # @example
+    #   mask_write_register(1, 0xAAAA, 0x00FF) => self
+    # @param [Integer] addr address registers
+    # @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)
+      self
+    end
+
+    # Request pdu to slave device
+    #
+    # @param [String] pdu request to slave
+    # @return [String] received data
+    #
+    # @raise [ModBusTimeout] timed out during read attempt
+    # @raise [ModBusException] unknown error
+    # @raise [IllegalFunction] function code received in the query is not an allowable action for the server
+    # @raise [IllegalDataAddress] data address received in the query is not an allowable address for the server
+    # @raise [IllegalDataValue] value contained in the query data field is not an allowable value for server
+    # @raise [SlaveDeviceFailure] unrecoverable error occurred while the server was attempting to perform the requested action
+    # @raise [Acknowledge] server has accepted the request and is processing it, but a long duration of time will be required to do so
+    # @raise [SlaveDeviceBus] server is engaged in processing a long duration program command
+    # @raise [MemoryParityError] extended file area failed to pass a consistency check
+    def query(pdu)
+      tried = 0
+      begin
+        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"
+      end
+
+      return nil if pdu.size == 0
+
+      if pdu.getbyte(0) >= 0x80
+        exc_id = pdu.getbyte(1)
+        raise Exceptions[exc_id] unless Exceptions[exc_id].nil?
+
+        raise ModBusException.new, "Unknown error"
+      end
+      pdu[2..-1]
+    end
+  end
+end

data/lib/rmodbus/sp.rb

@@ -0,0 +1,45 @@
+# 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.
+
+require 'serialport'
+
+module ModBus
+  module SP
+    attr_reader :port, :baud, :data_bits, :stop_bits, :parity, :read_timeout
+    # Open serial port
+    # @param [String] port name serial ports ("/dev/ttyS0" POSIX, "com1" - Windows)
+    # @param [Integer] baud rate serial port (default 9600)
+    # @param [Hash] opts the options of serial port
+    #
+    # @option opts [Integer] :data_bits from 5 to 8
+    # @option opts [Integer] :stop_bits 1 or 2
+    # @option opts [Integer] :parity NONE, EVEN or ODD
+    # @option opts [Integer] :read_timeout default 100 ms
+    # @return [SerialPort] io serial port
+    def open_serial_port(port, baud, opts = {})
+      @port, @baud = port, baud
+
+      @data_bits, @stop_bits, @parity, @read_timeout = 8, 1, SerialPort::NONE, 100
+
+      @data_bits = opts[:data_bits] unless opts[:data_bits].nil?
+      @stop_bits = opts[:stop_bits] unless opts[:stop_bits].nil?
+      @parity = opts[:parity] unless opts[:parity].nil?
+      @read_timeout = options[:read_timeout] unless opts[:read_timeout].nil?
+
+      io = SerialPort.new(@port, @baud, @data_bits, @stop_bits, @parity)
+      io.read_timeout = @read_timeout
+      io
+    end
+  end
+end

data/lib/rmodbus/tcp.rb

@@ -0,0 +1,49 @@
+# RModBus - free implementation of ModBus protocol on 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.
+require 'socket'
+require 'timeout'
+
+module ModBus
+  module TCP
+    include Timeout
+    attr_reader :ipaddr, :port
+
+    private
+    # Open TCP socket
+    #
+    # @param [String] ipaddr IP address of remote server
+    # @param [Integer] port connection port
+    # @param [Hash] opts options of connection
+    # @option opts [Float, Integer] :connect_timeout seconds timeout for open socket
+    # @return [TCPSocket] socket
+    #
+    # @raise [ModBusTimeout] timed out attempting to create connection
+    def open_tcp_connection(ipaddr, port, opts = {})
+      @ipaddr, @port = ipaddr, port
+
+      opts[:connect_timeout] ||= 1
+
+      io = nil
+      begin
+        timeout(opts[:connect_timeout], ModBusTimeout) do
+          io = TCPSocket.new(@ipaddr, @port)
+        end
+      rescue ModBusTimeout => err
+        raise ModBusTimeout.new, 'Timed out attempting to create connection'
+      end
+
+      io
+    end
+  end
+end

data/lib/rmodbus/tcp_client.rb

@@ -1,6 +1,6 @@
 # RModBus - free implementation of ModBus protocol on Ruby.
 #
-# Copyright (C) 2008  Timin Aleksey
+# Copyright (C) 2008-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,98 +11,29 @@
 # 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 'socket'
-require 'timeout'
-require 'rmodbus/client'
-require 'rmodbus/exceptions'
-
 module ModBus
-
-  # Implementation clients(master) ModBusTCP
+  # TCP client implementation
+  # @example
+  #   TCPClient.connect('127.0.0.1', 502) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see TCPClient#open_connection
+  # @see Client#initialize
   class TCPClient < Client
+    include TCP
 
-    include Timeout
-
-    attr_reader :ipaddr, :port, :slave, :transaction
-    attr_accessor :debug
-    
-    # Connect with ModBus server
-    #
-    # ipaddr - ip of the server
-    #
-    # port - port TCP connections
-    #
-    # slaveaddr - slave ID of the server
-    #
-    # TCPClient.connect('127.0.0.1') do |cl|
-    #
-    #   put cl.read_holding_registers(0, 10)
-    #
-    # end
-    def self.connect(ipaddr, port = 502, slaveaddr = 1)
-      cl = TCPClient.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 = 502, slaveaddr = 1)
-      @transaction = 0
-      @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?
+    protected
+    # Open TCP\IP connection
+    # @see TCP::open_connection
+    def open_connection(ipaddr, port = 502, opts = {})
+      open_tcp_connection(ipaddr, port, opts)
     end
 
-    # Check TCP connections
-    def closed?
-      @sock.closed?
+    def get_slave(uid, io)
+      TCPSlave.new(uid, io)
     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
-      @sock.write msg
-      
-      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
-        len = header[4,2].unpack('n')[0]       
-        msg = @sock.read(len-1)               
-
-        log "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg)
-        msg
-      else
-        raise Errors::ModBusException.new("Server did not respond")
-      end
-    end
-
   end
-
 end

data/lib/rmodbus/tcp_server.rb

@@ -11,35 +11,32 @@
 # 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
+  # TCP server implementation
+  # @example
+  #   srv = TCPServer.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 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
-
+		include Server 
+    
+    # Init server
+    # @param [Integer] port listen port
+    # @param [Integer] uid slave device
 		def initialize(port = 502, uid = 1)
-			@coils = []
-			@discrete_inputs = []
-			@holding_registers =[]
-			@input_registers = []
 			@uid = uid
 			super(port)
 		end
 
+    # Serve requests
+    # @param [TCPSocket] io socket
 		def serve(io)
 			loop do
 				req = io.read(7)

data/lib/rmodbus/tcp_slave.rb

@@ -0,0 +1,64 @@
+# RModBus - free implementation of ModBus protocol on 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
+  # TCP slave implementation
+  # @example
+  #   TCP.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 TCPSlave < Slave
+    attr_reader :transaction
+
+    # @see Slave::initialize
+    def initialize(uid, io)
+      @transaction = 0
+      super(uid, io)
+    end
+
+    private
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+    def send_pdu(pdu)
+      @transaction = 0 if @transaction.next > 65535
+      @transaction += 1
+      msg = @transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @uid.chr + pdu
+      @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
+      header = @io.read(7)
+      if header
+        tin = header[0,2].unpack('n')[0]
+        raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @transaction
+        len = header[4,2].unpack('n')[0]
+        msg = @io.read(len-1)
+
+        log "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg)
+        msg
+      else
+        raise Errors::ModBusException.new("Server did not respond")
+      end
+    end
+  end
+end

data/lib/rmodbus/version.rb

@@ -0,0 +1,17 @@
+# RModBus - free implementation of ModBus protocol on 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
+  # Package version
+  VERSION = '1.0.0'
+end

data/lib/rmodbus.rb

@@ -1,5 +1,5 @@
 # RModBus - free implementation of ModBus protocol on Ruby.
-# Copyright (C) 2008  Timin Aleksey
+# Copyright (C) 2008 - 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
@@ -9,11 +9,27 @@
 # 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/errors'
+require 'rmodbus/ext'
 require 'rmodbus/common'
+require 'rmodbus/rtu'
+require 'rmodbus/tcp'
+require 'rmodbus/slave'
+require 'rmodbus/client'
+require 'rmodbus/server'
+require 'rmodbus/tcp_slave'
 require 'rmodbus/tcp_client'
 require 'rmodbus/tcp_server'
-require 'rmodbus/rtu_client'
-require 'rmodbus/rtu_server'
+
+# jruby not support serial RTU protocol yet
+unless RUBY_PLATFORM == "java"
+  require 'rmodbus/sp'
+  require 'rmodbus/rtu_slave'
+  require 'rmodbus/rtu_client'
+  require 'rmodbus/rtu_server'
+end
+
+require 'rmodbus/rtu_via_tcp_slave'
 require 'rmodbus/rtu_via_tcp_client'
 require 'rmodbus/rtu_via_tcp_server'
-
+require 'rmodbus/proxy'