rmodbus 0.5.0 → 1.0.0

data/spec/rtu_via_tcp_client_spec.rb

@@ -1,72 +1,78 @@
-begin
-  require 'rubygems'
-rescue
-end
 require 'rmodbus'
-
 include ModBus
 
 describe RTUViaTCPClient do
+  describe "method 'query'" 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)
+      
+      @cl = RTUViaTCPClient.new("127.0.0.1")
+      @slave = @cl.with_slave(1)
+      @slave.read_retries = 0
+    end
     
-  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 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
+      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) 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 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
+  it "should tune connection timeout" do
+    timeout(0.5) do
+      lambda { RTUViaTCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.1) }.should raise_error(ModBusTimeout)
     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/slave_spec.rb

@@ -0,0 +1,55 @@
+require 'rmodbus'
+include ModBus
+
+describe Slave do
+  before do
+    @slave = 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/tcp_client_spec.rb

@@ -1,73 +1,81 @@
-require 'rmodbus/tcp_client'
-
-include ModBus
-
-describe TCPClient, "method 'query'"  do
-
-  UID = 1
-
-  before(:each) do
-    @sock = mock("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('')
-
-    @mb_client = TCPClient.new('127.0.0.1', 1502)
-  end
-
-  it 'should send valid MBAP Header' do
-    @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] = @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
-      @mb_client.query('').should == nil
-    rescue Exception => ex
-      ex.class.should == Errors::ModBusException
+require 'rmodbus'
+
+describe TCPClient do
+  describe "method 'query'" do    
+    before(:each) do
+      @uid = 1
+      @sock = mock("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('')
+      @cl = ModBus::TCPClient.new('127.0.0.1', 1502)
+      @slave = @cl.with_slave(@uid)
     end
-  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 = @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)
-
-    @mb_client.query(request).should == response[2..-1]
-  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)
-    TCPClient.connect(ipaddr, port, slave) do |cl|
-      cl.ipaddr.should == ipaddr
-      cl.port.should == port
-      cl.slave.should == slave
+    
+    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 throw exception 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)
+      begin
+        @slave.query('').should == nil
+      rescue Exception => ex
+        ex.class.should == Errors::ModBusException
+      end
+    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
+        TCPSocket.should_receive(:new).with(ipaddr, port).and_return(@sock)
+        @sock.should_receive(:closed?).and_return(false)
+        @sock.should_receive(:close)
+        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
+    timeout(0.5) do
+      lambda { ModBus::TCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.1) }.should raise_error(ModBusTimeout)
     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_server_spec.rb

@@ -1,7 +1,6 @@
-require 'lib/rmodbus'
+require 'rmodbus'
 
 describe TCPServer do
-  
   before do
     @server = ModBus::TCPServer.new(8502,1)
     @server.coils = [1,0,1,1]
@@ -9,104 +8,90 @@ describe TCPServer do
     @server.holding_registers = [1,2,3,4]
     @server.input_registers = [1,2,3,4]
     @server.start
-    @client = ModBus::TCPClient.new('127.0.0.1', 8502, 1)
-    @client.read_retries = 0
+    @cl = ModBus::TCPClient.new('127.0.0.1', 8502)
+    @slave = @cl.with_slave(1)
+    @slave.read_retries = 0
   end
 
   it "should silent if UID has mismatched" do
-    @client.close
-    client = ModBus::TCPClient.new('127.0.0.1', 8502, 2)
-    begin
-      client.read_coils(1,3)
-    rescue ModBus::Errors::ModBusException => ex
-      ex.message.should == "Server did not respond"
+    @cl.close
+    ModBus::TCPClient.connect('127.0.0.1', 8502) do |cl|
+      lambda { cl.with_slave(2).read_coils(1,3) }.should raise_exception(
+        ModBus::Errors::ModBusException, 
+        "Server did not respond"
+      )
     end
-    client.close
-  end
-
-  it "should silent if protocol identifer has mismatched" do
-    @client.close
-    client = TCPSocket.new('127.0.0.1', 8502)
-    begin
-      client.write "\0\0\1\0\0\6\1"
-    rescue ModBus::Errors::ModBusException => ex
-      ex.message.should == "Server did not respond"
-    end
-    client.close
   end
 
   it "should send exception if function not supported" do
-    begin 
-      @client.query('0x43') 
-    rescue ModBus::Errors::IllegalFunction => ex
-      ex.message.should == "The function code received in the query is not an allowable action for the server"  
-    end 
+    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 out more 0x7d" do
-    begin
-      @client.read_coils(0, 0x7e)
-    rescue ModBus::Errors::IllegalDataValue => ex
-      ex.message.should == "A value contained in the query data field is not an allowable value for server"
-    end
+    lambda { @slave.read_coils(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 "should send exception if addr not valid" do
-    begin
-      @client.read_coils(2, 8)
-    rescue ModBus::Errors::IllegalDataAddress => ex
-      ex.message.should == "The data address received in the query is not an allowable address for the server"
-    end
+    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 calc a many requests" do
-    @client.read_coils(1,2)
-    @client.write_multiple_registers(0,[9,9,9,])
-    @client.read_holding_registers(0,3).should == [9,9,9]
+    @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
-    @client.read_coils(0,3).should == @server.coils[0,3]
+    @slave.read_coils(0,3).should == @server.coils[0,3]
   end
 
   it "should supported function 'read discrete inputs'" do
-    @client.read_discrete_inputs(1,3).should == @server.discrete_inputs[1,3]
+    @slave.read_discrete_inputs(1,3).should == @server.discrete_inputs[1,3]
   end
 
   it "should supported function 'read holding registers'" do
-    @client.read_holding_registers(0,3).should == @server.holding_registers[0,3]
+    @slave.read_holding_registers(0,3).should == @server.holding_registers[0,3]
   end
 
   it "should supported function 'read input registers'" do
-    @client.read_input_registers(2,2).should == @server.input_registers[2,2]
+    @slave.read_input_registers(2,2).should == @server.input_registers[2,2]
   end
 
   it "should supported function 'write single coil'" do
     @server.coils[3] = 0
-    @client.write_single_coil(3,1)
+    @slave.write_single_coil(3,1)
     @server.coils[3].should == 1
   end
 
   it "should supported function 'write single register'" do
     @server.holding_registers[3] = 25
-    @client.write_single_register(3,35)
+    @slave.write_single_register(3,35)
     @server.holding_registers[3].should == 35
   end
 
   it "should supported function 'write multiple coils'" do
     @server.coils = [1,1,1,0, 0,0,0,0, 0,0,0,0, 0,1,1,1]
-    @client.write_multiple_coils(3, [1, 0,1,0,1, 0,1,0,1])
+    @slave.write_multiple_coils(3, [1, 0,1,0,1, 0,1,0,1])
     @server.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.holding_registers = [1,2,3,4,5,6,7,8,9]
-    @client.write_multiple_registers(3,[1,2,3,4,5])
+    @slave.write_multiple_registers(3,[1,2,3,4,5])
     @server.holding_registers.should == [1,2,3,1,2,3,4,5,9]
   end
 
   after do
-    @client.close 
+    @cl.close 
     @server.stop unless @server.stopped?
     while GServer.in_service?(8502) 
     end