rmodbus-ccutrer 2.0.0 → 2.1.1

data/spec/rtu_server_spec.rb

@@ -1,31 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::RTUServer do
-  before do
-    @sp = double('SerialPort')
-    SerialPort.should_receive(:new).with('/dev/ttyS0', 4800, 7, 2, SerialPort::NONE).and_return(@sp)
-    @sp.stub(:read_timeout=)
-    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-
-    @server = ModBus::RTUServer.new('/dev/ttyS0', 4800, :data_bits => 7, :stop_bits => 2)
-    @slave = @server.with_slave(1)
-    @slave.coils = [1,0,1,1]
-    @slave.discrete_inputs = [1,1,0,0]
-    @slave.holding_registers = [1,2,3,4]
-    @slave.input_registers = [1,2,3,4]
-  end
-
-  it "should be valid initialized " do
-    @slave.coils.should == [1,0,1,1]
-    @slave.discrete_inputs.should == [1,1,0,0]
-    @slave.holding_registers.should == [1,2,3,4]
-    @slave.input_registers.should == [1,2,3,4]
-
-    @server.port.should == '/dev/ttyS0'
-    @server.baud.should == 4800
-    @server.data_bits.should == 7
-    @server.stop_bits.should == 2
-    @server.parity.should == SerialPort::NONE
-  end
-end

data/spec/rtu_via_tcp_client_spec.rb

@@ -1,76 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::RTUClient do
-  describe "method 'query'" do
-    before do
-      @sock = double('Socket')
-      Socket.should_receive(:tcp).with("127.0.0.1", 10002, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
-      @sock.stub(:read_timeout=)
-      @sock.stub(:flush)
-
-      @cl = ModBus::RTUClient.new("127.0.0.1")
-      @slave = @cl.with_slave(1)
-      @slave.read_retries = 1
-    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 {@slave.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 {@slave.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")
-      @slave.query(request).should == "\xff\xff"
-    end
-
-    it 'should sugar connect method' do
-      ipaddr, port = '127.0.0.1', 502
-      Socket.should_receive(:tcp).with(ipaddr, port, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
-      @sock.should_receive(:closed?).and_return(false)
-      @sock.should_receive(:close)
-      ModBus::RTUClient.connect(ipaddr, port) do |cl|
-        cl.ipaddr.should == ipaddr
-        cl.port.should == port
-      end
-    end
-
-    it 'should have closed? method' do
-      @sock.should_receive(:closed?).and_return(false)
-      @cl.closed?.should == false
-
-      @sock.should_receive(:closed?).and_return(false)
-      @sock.should_receive(:close)
-
-      @cl.close
-
-      @sock.should_receive(:closed?).and_return(true)
-      @cl.closed?.should == true
-    end
-
-    it 'should give slave object in block' do
-      @cl.with_slave(1) do |slave|
-        slave.uid = 1
-      end
-    end
-  end
-
-  it "should tune connection timeout" do
-    lambda { ModBus::RTUClient.new('81.123.231.11', 1999, :connect_timeout => 0.001) }.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-end

data/spec/rtu_via_tcp_server_spec.rb

@@ -1,89 +0,0 @@
-# -*- coding: ascii
-require "rmodbus"
-
-describe ModBus::RTUViaTCPServer do
-  before :all do
-    @port = 8502
-    begin
-      @server = ModBus::RTUViaTCPServer.new(@port)
-      @server_slave = @server.with_slave(1)
-      @server_slave.coils = [1,0,1,1]
-      @server_slave.discrete_inputs = [1,1,0,0]
-      @server_slave.holding_registers = [1,2,3,4]
-      @server_slave.input_registers = [1,2,3,4]
-      @server.promiscuous = true
-      @server.start
-    rescue Errno::EADDRINUSE
-      @port += 1
-      retry
-    end
-    @cl = ModBus::RTUClient.new('127.0.0.1', @port)
-    @cl.read_retries = 1
-    @slave = @cl.with_slave(1)
-    # pretend this is a serialport and we're just someone else on the same bus
-    @io = @cl.instance_variable_get(:@io)
-  end
-
-  before do
-    @server.debug = false
-  end
-
-  it "should have options :host" do
-    host = '192.168.0.1'
-    srv = ModBus::RTUViaTCPServer.new(1010, :host => '192.168.0.1')
-    srv.host.should eql(host)
-  end
-
-  it "should have options :max_connection" do
-    max_conn = 5
-    srv = ModBus::RTUViaTCPServer.new(1010, :max_connection => 5)
-    srv.maxConnections.should eql(max_conn)
-  end
-
-  it "should properly ignore responses from other slaves" do
-    request = "\x10\x03\x0\x1\x0\x1\xd6\x8b"
-    response = "\x10\x83\x1\xd0\xf5"
-    @server.debug = true
-    @server.should receive(:log).ordered.with("Server RX (8 bytes): [10][03][00][01][00][01][d6][8b]")
-    @server.should receive(:log).ordered.with("Server RX function 3 to 16: {:quant=>1, :addr=>1}")
-    @server.should receive(:log).ordered.with("Server RX (5 bytes): [10][83][01][d0][f5]")
-    @server.should receive(:log).ordered.with("Server RX response 3 from 16: {:err=>1}")
-    @server.should receive(:log).ordered.with("Server RX (8 bytes): [01][01][00][00][00][01][fd][ca]")
-    @server.should receive(:log).ordered.with("Server RX function 1 to 1: {:quant=>1, :addr=>0}")
-    @server.should receive(:log).ordered.with("Server TX (6 bytes): [01][01][01][01][90][48]")
-    @io.write(request)
-    @io.write(response)
-    # just to prove the server can still handle subsequent requests
-    @slave.read_coils(0, 1).should == [1]
-  end
-
-  it "should properly ignore functions from other slaves that it doesn't understand" do
-    request = "\x10\x41\x0\x1\x0\x1\x0\x5\x0\x1\xb1\x00"
-    response = "\x10\xc1\x1\xe0\x55"
-    @io.write(request)
-    @io.write(response)
-    # just to prove the server can still handle subsequent requests
-    @slave.read_coils(0, 1).should == [1]
-  end
-
-  it "should properly ignore utter garbage on the line from starting up halfway through a conversation" do
-    response = "garbage" * 50 + "\x1\x55\xe0"
-    @io.write(response)
-    # just to prove the server can still handle subsequent requests
-    @slave.read_coils(0, 1).should == [1]
-  end
-
-  it "should send exception if request is malformed" do
-    lambda { @slave.query("\x01\x01") }.should raise_exception(
-                                                   ModBus::Errors::ModBusTimeout)
-  end
-
-  after :all do
-    @cl.close unless @cl.closed?
-    @server.stop unless @server.stopped?
-    while GServer.in_service?(@port)
-      sleep(0.01)
-    end
-    @server.stop
-  end
-end

data/spec/slave_spec.rb

@@ -1,55 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::Client::Slave do
-  before do
-    @slave = ModBus::Client.new.with_slave(1)
-
-    @slave.stub(:query).and_return('')
-  end
-
-  it "should support function 'read coils'" do
-    @slave.should_receive(:query).with("\x1\x0\x13\x0\x13").and_return("\xcd\x6b\x5")    
-    @slave.read_coils(0x13,0x13).should == [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
-  end
-
-  it "should support function 'read discrete inputs'" do
-    @slave.should_receive(:query).with("\x2\x0\xc4\x0\x16").and_return("\xac\xdb\x35")    
-    @slave.read_discrete_inputs(0xc4,0x16).should == [0,0,1,1, 0,1,0,1, 1,1,0,1, 1,0,1,1, 1,0,1,0, 1,1]
-  end
-
-  it "should support function 'read holding registers'" do
-    @slave.should_receive(:query).with("\x3\x0\x6b\x0\x3").and_return("\x2\x2b\x0\x0\x0\x64")    
-    @slave.read_holding_registers(0x6b,0x3).should == [0x022b, 0x0000, 0x0064]
-  end
-
-  it "should support function 'read input registers'" do
-    @slave.should_receive(:query).with("\x4\x0\x8\x0\x1").and_return("\x0\xa")    
-    @slave.read_input_registers(0x8,0x1).should == [0x000a]
-  end
-
-  it "should support function 'write single coil'" do
-    @slave.should_receive(:query).with("\x5\x0\xac\xff\x0").and_return("\xac\xff\x00")    
-    @slave.write_single_coil(0xac,0x1).should == @slave
-  end
-
-  it "should support function 'write single register'" do
-    @slave.should_receive(:query).with("\x6\x0\x1\x0\x3").and_return("\x1\x0\x3")    
-    @slave.write_single_register(0x1,0x3).should == @slave
-  end
-
-  it "should support function 'write multiple coils'" do
-    @slave.should_receive(:query).with("\xf\x0\x13\x0\xa\x2\xcd\x1").and_return("\x13\x0\xa")    
-    @slave.write_multiple_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]).should == @slave
-  end
-
-  it "should support function 'write multiple registers'" do
-    @slave.should_receive(:query).with("\x10\x0\x1\x0\x3\x6\x0\xa\x1\x2\xf\xf").and_return("\x1\x0\x3")    
-    @slave.write_multiple_registers(0x1,[0x000a,0x0102, 0xf0f]).should == @slave
-  end
-
-  it "should support function 'mask write register'" do
-    @slave.should_receive(:query).with("\x16\x0\x4\x0\xf2\x0\2").and_return("\x4\x0\xf2\x0\x2")
-    @slave.mask_write_register(0x4, 0xf2, 0x2).should == @slave
-  end
-end

data/spec/spec_helper.rb

@@ -1,54 +0,0 @@
-# -*- coding: ascii
-require "rmodbus"
-
-class RaiseResponseMismatch
-  def initialize(message, request, response)
-    @expected_message, @expected_request, @expected_response = message, request, response
-  end
-
-  def matches?(given_block)
-    begin
-      given_block.call
-    rescue ModBus::Errors::ResponseMismatch => e
-      @actual_message = e.message
-      @actual_request = e.request
-      @actual_response = e.response
-
-      @with_expected_message = verify_message
-      @with_expected_request = @expected_request == @actual_request
-      @with_expected_response = @expected_response == @actual_response
-    end
-    @with_expected_message & @with_expected_request & @with_expected_response
-  end
-
-  def failure_message
-    unless @with_expected_message
-      return "Expected message '#{@expected_message}', got '#{@actual_message}'"
-    end
-
-    unless @with_expected_request
-      return "Expected request #{logging_bytes @expected_request}, got #{logging_bytes @actual_request}"
-    end
-
-    unless @with_expected_response
-      return "Expected response #{logging_bytes @expected_response}, got #{logging_bytes @actual_response}"
-    end
-  end
-
-  def verify_message
-    case  @expected_message
-      when nil
-        true
-      when Regexp
-         @expected_message =~ @actual_message
-      else
-         @expected_message == @actual_message
-    end
-  end
-end
-
-module RaiseResponseMatcher
-  def raise_response_mismatch(message, request, response)
-    RaiseResponseMismatch.new(message, request, response)
-  end
-end

data/spec/tcp_client_spec.rb

@@ -1,88 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::TCPClient do
-  describe "method 'query'" do    
-    before(:each) do
-      @uid = 1
-      @sock = double('Socket')
-      @adu = "\000\001\000\000\000\001\001"
-  
-      Socket.should_receive(:tcp).with('127.0.0.1', 1502, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
-      @sock.stub(:read).with(0).and_return('')
-      @cl = ModBus::TCPClient.new('127.0.0.1', 1502)
-      @slave = @cl.with_slave(@uid)
-    end
-    
-    it 'should send valid MBAP Header' do
-      @adu[0,2] = @slave.transaction.next.to_word
-      @sock.should_receive(:write).with(@adu)
-      @sock.should_receive(:read).with(7).and_return(@adu)
-      @slave.query('').should == nil
-    end
-    
-    it 'should not throw exception and white next packet if get other transaction' 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)
-
-      expect{ @slave.query('') }.to_not raise_error
-    end
-    
-    it 'should throw timeout exception if do not get own transaction' do
-      @slave.read_retries = 2
-      @adu[0,2] = @slave.transaction.next.to_word
-      @sock.should_receive(:write).at_least(1).times.with(/\.*/)
-      @sock.should_receive(:read).at_least(1).times.with(7).and_return("\000\x3\000\000\000\001" + @uid.chr)
-
-      expect{ @slave.query('') }.to raise_error(ModBus::Errors::ModBusTimeout, "Timed out during read attempt")
-    end
-
-    
-    it 'should return only data from PDU' do
-      request = "\x3\x0\x6b\x0\x3"
-      response = "\x3\x6\x2\x2b\x0\x0\x0\x64"
-      @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)
-  
-      @slave.query(request).should == response[2..-1]
-    end
-    
-    it 'should sugar connect method' do
-        ipaddr, port = '127.0.0.1', 502
-        Socket.should_receive(:tcp).with(ipaddr, port, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
-        @sock.should_receive(:closed?).and_return(false)
-        @sock.should_receive(:close)
-        ModBus::TCPClient.connect(ipaddr, port) do |cl|
-          cl.ipaddr.should == ipaddr
-          cl.port.should == port
-        end
-      end
-    
-    it 'should have closed? method' do
-      @sock.should_receive(:closed?).and_return(false)
-      @cl.closed?.should == false
-  
-      @sock.should_receive(:closed?).and_return(false)
-      @sock.should_receive(:close)
-  
-      @cl.close
-  
-      @sock.should_receive(:closed?).and_return(true)
-      @cl.closed?.should == true
-    end 
-    
-    it 'should give slave object in block' do
-      @cl.with_slave(1) do |slave|
-        slave.uid = 1
-      end
-    end
-  end  
-  
-  it "should tune connection timeout" do
-    lambda { ModBus::TCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.001) }.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-end

data/spec/tcp_server_spec.rb

@@ -1,158 +0,0 @@
-# -*- coding: ascii
-require "rmodbus"
-
-describe ModBus::TCPServer do
-  before :all do
-    unit_ids = (1..247).to_a.shuffle
-    valid_unit_id = unit_ids.first
-    @invalid_unit_id = unit_ids.last
-    @port = 8502
-    begin
-      @server = ModBus::TCPServer.new(@port)
-      @server_slave = @server.with_slave(valid_unit_id)
-      @server_slave.coils = [1,0,1,1]
-      @server_slave.discrete_inputs = [1,1,0,0]
-      @server_slave.holding_registers = [1,2,3,4]
-      @server_slave.input_registers = [1,2,3,4]
-      @server.start
-    rescue Errno::EADDRINUSE
-      @port += 1
-      retry
-    end
-    @cl = ModBus::TCPClient.new('127.0.0.1', @port)
-    @cl.read_retries = 1
-    @slave = @cl.with_slave(valid_unit_id)
-  end
-
-  it "should succeed if UID is broadcast" do
-    @cl.with_slave(0).write_coil(1,1)
-    # have to wait for the server to process it
-    sleep 1
-    @server_slave.coils[1].should == 1
-  end
-
-  it "should fail if UID is mismatched" do
-    lambda { @cl.with_slave(@invalid_unit_id).read_coils(1,3) }.should raise_exception(
-      ModBus::Errors::ModBusTimeout
-    )
-  end
-
-  it "should send exception if function not supported" do
-    lambda { @slave.query('0x43') }.should raise_exception(
-      ModBus::Errors::IllegalFunction,
-      "The function code received in the query is not an allowable action for the server"
-    )
-  end
-
-  it "should send exception if quanity of registers are more than 0x7d" do
-    lambda { @slave.read_holding_registers(0, 0x7e) }.should raise_exception(
-      ModBus::Errors::IllegalDataValue,
-      "A value contained in the query data field is not an allowable value for server"
-    )
-  end
-
-  it "shouldn't send exception if quanity of coils are more than 0x7d0" do
-    lambda { @slave.read_coils(0, 0x7d1) }.should raise_exception(
-      ModBus::Errors::IllegalDataValue,
-      "A value contained in the query data field is not an allowable value for server"
-    )
-  end
-
-  it "should send exception if addr not valid" do
-    lambda { @slave.read_coils(2, 8) }.should raise_exception(
-      ModBus::Errors::IllegalDataAddress,
-      "The data address received in the query is not an allowable address for the server"
-    )
-  end
-
-  it "should send exception if function not supported" do
-    lambda { @slave.query('0x43') }.should raise_exception(
-                                               ModBus::Errors::IllegalFunction,
-                                               "The function code received in the query is not an allowable action for the server"
-                                           )
-  end
-
-  it "should calc a many requests" do
-    @slave.read_coils(1,2)
-    @slave.write_multiple_registers(0,[9,9,9,])
-    @slave.read_holding_registers(0,3).should == [9,9,9]
-  end
-
-  it "should supported function 'read coils'" do
-    @slave.read_coils(0,3).should == @server_slave.coils[0,3]
-  end
-
-  it "should supported function 'read coils' with more than 125 in one request" do
-    @server_slave.coils = Array.new( 1900, 1 )
-    @slave.read_coils(0,1900).should == @server_slave.coils[0,1900]
-  end
-
-  it "should supported function 'read discrete inputs'" do
-    @slave.read_discrete_inputs(1,3).should == @server_slave.discrete_inputs[1,3]
-  end
-
-  it "should supported function 'read holding registers'" do
-    @slave.read_holding_registers(0,3).should == @server_slave.holding_registers[0,3]
-  end
-
-  it "should supported function 'read input registers'" do
-    @slave.read_input_registers(2,2).should == @server_slave.input_registers[2,2]
-  end
-
-  it "should supported function 'write single coil'" do
-    @server_slave.coils[3] = 0
-    @slave.write_single_coil(3,1)
-    @server_slave.coils[3].should == 1
-  end
-
-  it "should supported function 'write single register'" do
-    @server_slave.holding_registers[3] = 25
-    @slave.write_single_register(3,35)
-    @server_slave.holding_registers[3].should == 35
-  end
-
-  it "should supported function 'write multiple coils'" do
-    @server_slave.coils = [1,1,1,0, 0,0,0,0, 0,0,0,0, 0,1,1,1]
-    @slave.write_multiple_coils(3, [1, 0,1,0,1, 0,1,0,1])
-    @server_slave.coils.should == [1,1,1,1, 0,1,0,1, 0,1,0,1, 0,1,1,1]
-  end
-
-  it "should supported function 'write multiple registers'" do
-    @server_slave.holding_registers = [1,2,3,4,5,6,7,8,9]
-    @slave.write_multiple_registers(3,[1,2,3,4,5])
-    @server_slave.holding_registers.should == [1,2,3,1,2,3,4,5,9]
-  end
-
-  it "should support function 'mask_write_register'" do
-    @server_slave.holding_registers = [0x12]
-    @slave.mask_write_register(0, 0xf2, 0x25)
-    @server_slave.holding_registers.should == [0x17]
-  end
-
-  it "should support function 'read_write_multiple_registers'" do
-    @server_slave.holding_registers = [1,2,3,4,5,6,7,8,9]
-    @slave.read_write_multiple_registers(0, 5, 4, [3,2,1]).should == [1,2,3,4,3]
-    @server_slave.holding_registers.should == [1,2,3,4,3,2,1,8,9]
-  end
-
-  it "should have options :host" do
-    host = '192.168.0.1'
-    srv = ModBus::TCPServer.new(1010, :host => '192.168.0.1')
-    srv.host.should eql(host)
-  end
-
-  it "should have options :max_connection" do
-    max_conn = 5
-    srv = ModBus::TCPServer.new(1010, :max_connection => 5)
-    srv.maxConnections.should eql(max_conn)
-  end
-
-  after :all do
-    @cl.close unless @cl.closed?
-    @server.stop unless @server.stopped?
-    while GServer.in_service?(@port)
-      sleep(0.01)
-    end
-    @server.stop
-  end
-end