rmodbus 1.3.2 → 2.1.2

data/lib/rmodbus/slave.rb

@@ -1,308 +0,0 @@
-module ModBus
-  class Slave
-    include Errors
-    include Debug
-    include Options
-    # Number of times to retry on read and read timeouts
-    attr_accessor :uid
-    Exceptions = {
-          1 => IllegalFunction.new("The function code received in the query is not an allowable action for the server"),
-          2 => IllegalDataAddress.new("The data address received in the query is not an allowable address for the server"),
-          3 => IllegalDataValue.new("A value contained in the query data field is not an allowable value for server"),
-          4 => SlaveDeviceFailure.new("An unrecoverable error occurred while the server was attempting to perform the requested action"),
-          5 => Acknowledge.new("The server has accepted the request and is processing it, but a long duration of time will be required to do so"),
-          6 => SlaveDeviceBus.new("The server is engaged in processing a long duration program command"),
-          8 => MemoryParityError.new("The extended file area failed to pass a consistency check")
-    }
-    def initialize(uid, io)
-	    @uid = uid
-      @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 [ResponseMismatch] the received echo response differs from the request
-    # @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(request)
-      tried = 0
-      response = ""
-      begin
-        ::Timeout.timeout(@read_retry_timeout, ModBusTimeout) do
-          send_pdu(request)
-          response = 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 response.size == 0
-
-      read_func = response.getbyte(0)
-      if read_func >= 0x80
-        exc_id = response.getbyte(1)
-        raise Exceptions[exc_id] unless Exceptions[exc_id].nil?
-
-        raise ModBusException.new, "Unknown error"
-      end
-
-      check_response_mismatch(request, response) if raise_exception_on_mismatch
-      response[2..-1]
-    end
-
-    private
-    def check_response_mismatch(request, response)
-      read_func = response.getbyte(0)
-      data = response[2..-1]
-      #Mismatch functional code
-      send_func = request.getbyte(0)
-      if read_func != send_func
-        msg = "Function code is mismatch (expected #{send_func}, got #{read_func})"
-      end
-
-      case read_func
-      when 1,2
-        bc = request.getword(3)/8 + 1
-        if data.size != bc
-          msg = "Byte count is mismatch (expected #{bc}, got #{data.size} bytes)"
-        end
-      when 3,4
-        rc = request.getword(3)
-        if data.size/2 != rc
-          msg = "Register count is mismatch (expected #{rc}, got #{data.size/2} regs)"
-        end
-      when 5,6
-        exp_addr = request.getword(1)
-        got_addr = response.getword(1)
-        if exp_addr != got_addr
-          msg = "Address is mismatch (expected #{exp_addr}, got #{got_addr})"
-        end
-
-        exp_val = request.getword(3)
-        got_val = response.getword(3)
-        if exp_val != got_val
-          msg = "Value is mismatch (expected 0x#{exp_val.to_s(16)}, got 0x#{got_val.to_s(16)})"
-        end
-      when 15,16
-        exp_addr = request.getword(1)
-        got_addr = response.getword(1)
-        if exp_addr != got_addr
-          msg = "Address is mismatch (expected #{exp_addr}, got #{got_addr})"
-        end
-
-        exp_quant = request.getword(3)
-        got_quant = response.getword(3)
-        if exp_quant != got_quant
-          msg = "Quantity is mismatch (expected #{exp_quant}, got #{got_quant})"
-        end
-      else
-        warn "Fuiction (#{read_func}) is not supported raising response mismatch"
-      end
-
-      raise ResponseMismatch.new(msg, request, response) if msg
-    end
-  end
-end

data/spec/client_spec.rb

@@ -1,88 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::Client do
-  before do
-    @cl = ModBus::Client.new
-  end
-
-  it "should give object provider for slave" do
-    slave = @cl.with_slave(1)
-    slave.uid.should eq(1)
-  end
-
-  it "should give object provider for slave in block" do
-    @cl.with_slave(1) do |slave|
-      slave.uid.should eq(1)
-    end
-  end
-  
-  it "should connect with TCP server" do
-    ModBus::Client.connect do |cl|
-      cl.should be_instance_of(ModBus::Client)
-    end
-  end
-  
-  it ":new alias :connect" do
-    ModBus::Client.new do |cl|
-      cl.should be_instance_of(ModBus::Client)
-    end
-  end
-
-  it "should close the connection when an exception is raised in the given block" do
-    expect {
-      ModBus::Client.new do |client|
-        client.should_receive(:close)
-        raise
-      end
-    }.to raise_error
-  end
-
-  it 'should common for all slaves :debug flag' do
-    @cl.debug = true
-    @cl.with_slave(1) do |slave_1|
-      slave_1.debug.should be_truthy
-    end
-    @cl.with_slave(2) do |slave_2|
-      slave_2.debug = false
-      slave_2.debug.should be_falsey
-    end
-  end
-
-  it 'should common for all slaves :raise_exception_on_mismatch flag' do
-    @cl.raise_exception_on_mismatch = true
-    @cl.with_slave(1) do |slave_1|
-      slave_1.raise_exception_on_mismatch.should be_truthy
-    end
-
-    @cl.with_slave(2) do |slave_2|
-      slave_2.raise_exception_on_mismatch = false
-      slave_2.raise_exception_on_mismatch.should be_falsey
-    end
-  end
-  
-  it 'should common for all slaves :read_retries options' do
-   @cl.read_retries = 5
-    @cl.with_slave(1) do |slave_1|
-      slave_1.read_retries.should eql(5)
-    end
-
-    @cl.with_slave(2) do |slave_2|
-      slave_2.read_retries = 15
-      slave_2.read_retries.should eql(15)
-    end
-  end
-
-  it 'should common for all slaves :read_retry_timeout options' do
-   @cl.read_retry_timeout = 5
-    @cl.with_slave(1) do |slave_1|
-      slave_1.read_retry_timeout.should eql(5)
-    end
-
-    @cl.with_slave(2) do |slave_2|
-      slave_2.read_retry_timeout = 15
-      slave_2.read_retry_timeout.should eql(15)
-    end
-  end
-
-end

data/spec/exception_spec.rb

@@ -1,119 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::TCPClient do
-  before(:all) do
-    @srv = ModBus::TCPServer.new(1502, 1)
-    @srv.coils = [0] * 8
-    @srv.discrete_inputs = [0] * 8
-    @srv.holding_registers = [0] * 8
-    @srv.input_registers = [0] * 8
-    @srv.start
-
-    @cl = ModBus::TCPClient.new('127.0.0.1', 1502)
-    @slave = @cl.with_slave(1)
-  end
-
-  it "should raise ProxException" do
-    lambda { @slave.holding_registers[0..2] = [0,0] }.should raise_error(ModBus::Errors::ProxyException)
-  end
-
-  # Read coil status
-  it "should read coil status" do
-    @slave.read_coils(0, 4).should == [0] * 4
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_coils(501, 34) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_coils(0, 0x07D1) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Read input status
-  it "should read discrete inputs" do
-    @slave.read_discrete_inputs(0, 4).should == [0] * 4
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_discrete_inputs(50, 23) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_discrete_inputs(0, 0x07D1) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Read holding registers
-  it "should read discrete inputs" do
-    @slave.read_holding_registers(0, 4).should == [0, 0, 0, 0]
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_holding_registers(402, 99) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_holding_registers(0, 0x007E) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Read input registers
-  it "should read discrete inputs" do
-    @slave.read_input_registers(0, 4).should == [0, 0, 0, 0]
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_input_registers(402, 9) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_input_registers(0, 0x007E) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Force single coil
-  it "should force single coil" do
-    @slave.write_single_coil(4, 1).should == @slave
-    @slave.read_coils(4, 4).should == [1, 0, 0, 0] 
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_single_coil(501, true) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  # Preset single register
-  it "should preset single register" do
-    @slave.write_single_register(4, 0x0AA0).should == @slave
-    @slave.read_holding_registers(4, 1).should == [0x0AA0] 
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_single_register(501, 0x0AA0) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  # Force multiple coils
-  it "should force multiple coils" do
-    @slave.write_multiple_coils(4, [0,1,0,1]).should == @slave
-    @slave.read_coils(3, 5).should == [0,0,1,0,1]
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_multiple_coils(501, [1,0]) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  # Preset multiple registers
-  it "should preset multiple registers" do
-    @slave.write_multiple_registers(4, [1, 2, 3, 0xAACC]).should == @slave
-    @slave.read_holding_registers(3, 5).should == [0, 1, 2, 3, 0xAACC] 
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_multiple_registers(501, [1, 2]) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  after(:all) do
-    @cl.close unless @cl.closed?
-    @srv.stop
-  end
-
-end

data/spec/ext_spec.rb

@@ -1,52 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-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
-    @arr.pack_to_word.should == "\xcd\x6b\x5" 
-  end
-
-  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
-
-  it "should turn an array into 32b ints" do
-    [20342, 17344].to_32i.should == [1136676726]
-    [20342, 17344, 20342, 17344].to_32i.size.should == 2
-  end
-
-  it "should turn an array into 32b floats big endian" do
-    [20342, 17344].to_32f[0].should be_within(0.1).of(384.620788574219)
-    [20342, 17344, 20342, 17344].to_32f.size.should == 2
-  end
-  
-  it "should turn a an array into 32b floats (little endian)" do
-    [17344, 20342].to_32f_le[0].should be_within(0.1).of(384.620788574219)
-    [17344, 20342, 17344, 20342].to_32f_le.size.should == 2
-  end
-
-  it "should turn an array from 32b ints into 16b ints, big endian" do
-    [1136676726].from_32i.should == [20342, 17344]
-    [1136676726, 1136676725].from_32i.should == [20342, 17344, 20341, 17344]
-  end
-
-  it "should turn an array from 32b floats into 16b ints, big endian" do
-    [384.620788].from_32f.should == [20342, 17344]
-    [384.620788, 384.620788].from_32f.should == [20342, 17344, 20342, 17344]
-  end
-
-  it "should raise exception if uneven number of elements" do
-   lambda { [20342, 17344, 123].to_32f }.should raise_error(StandardError)
-   lambda { [20342, 17344, 123].to_32i }.should raise_error(StandardError)
-  end
-end
-

data/spec/logging_spec.rb

@@ -1,89 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::TCPClient  do
-  before(:each) do
-    @uid = 1
-    @sock = double('Socket')
-    @adu = "\000\001\000\000\000\001\001"
-
-    TCPSocket.should_receive(:new).with('127.0.0.1', 1502).and_return(@sock)
-    @sock.stub(:read).with(0).and_return('')
-
-    @slave = ModBus::TCPClient.new('127.0.0.1', 1502).with_slave(@uid)
-    @slave.debug = true
-  end
-
-  it 'should log rec\send bytes' do
-    request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
-    mock_query(request,response)
-    $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]")
-    @slave.query(request)
-  end
-
-  it "should don't logging if debug disable" do
-    @slave.debug = false
-    request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
-    mock_query(request,response)
-    @slave.query(request)
-  end
-
-  it "should log warn message if transaction mismatch" do
-    @adu[0,2] = @slave.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)
-    @sock.should_receive(:read).with(7).and_return("\000\001\000\000\000\001" + @uid.chr)
-
-    $stdout.should_receive(:puts).with("Tx (7 bytes): [00][01][00][00][00][01][01]")
-    $stdout.should_receive(:puts).with("Rx (7 bytes): [00][02][00][00][00][01][01]")
-    $stdout.should_receive(:puts).with("Transaction number mismatch. A packet is ignored.")
-    $stdout.should_receive(:puts).with("Rx (7 bytes): [00][01][00][00][00][01][01]")
-
-    @slave.query('')
-  end
-
-  def mock_query(request, response)
-    @adu = @slave.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)
-  end
-end
-
-begin
-  require "serialport"
-  describe ModBus::RTUClient do
-    before do 
-      @sp = double('Serial port')
-
-      SerialPort.should_receive(:new).with("/dev/port1", 9600, 7, 2, SerialPort::ODD).and_return(@sp)
-      SerialPort.stub(:public_method_defined?).with(:flush_input).and_return(true)
-
-      @sp.stub(:class).and_return(SerialPort)
-      @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-      @sp.stub(:read_timeout=)
-      @sp.stub(:flush_input)
-
-      @slave = ModBus::RTUClient.new("/dev/port1", 9600, :data_bits => 7, :stop_bits => 2, :parity => SerialPort::ODD).with_slave(1)
-      @slave.read_retries = 0
-
-    end
-    
-    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(:flush_input)  # Clean a garbage
-      @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")
-      
-      @slave.debug = true
-      $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]")
-      
-      @slave.query(request).should == "\xff\xff"
-    end
-  end
-rescue LoadError
-end