rmodbus 0.5.0 → 1.0.0

data/spec/client_spec.rb

@@ -1,57 +1,31 @@
-require 'rmodbus/client'
-
+require 'rmodbus'
 include ModBus
 
 describe Client do
-
   before do
-    @cl_mb = Client.new
-    @cl_mb.stub!(:query).and_return('')
-  end
-
-  it "should support function 'read coils'" do
-    @cl_mb.should_receive(:query).with("\x1\x0\x13\x0\x13").and_return("\xcd\x6b\x5")    
-    @cl_mb.read_coils(0x13,0x13).should == [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
+    @cl = Client.new
   end
 
-  it "should support function 'read discrete inputs'" do
-    @cl_mb.should_receive(:query).with("\x2\x0\xc4\x0\x16").and_return("\xac\xdb\x35")    
-    @cl_mb.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]
+  it "should give object provider for slave" do
+    slave = @cl.with_slave(1)
+    slave.uid.should eq(1)
   end
 
-  it "should support function 'read holding registers'" do
-    @cl_mb.should_receive(:query).with("\x3\x0\x6b\x0\x3").and_return("\x2\x2b\x0\x0\x0\x64")    
-    @cl_mb.read_holding_registers(0x6b,0x3).should == [0x022b, 0x0000, 0x0064]
+  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 support function 'read input registers'" do
-    @cl_mb.should_receive(:query).with("\x4\x0\x8\x0\x1").and_return("\x0\xa")    
-    @cl_mb.read_input_registers(0x8,0x1).should == [0x000a]
-  end
-
-  it "should support function 'write single coil'" do
-    @cl_mb.should_receive(:query).with("\x5\x0\xac\xff\x0").and_return("\xac\xff\x00")    
-    @cl_mb.write_single_coil(0xac,0x1).should == @cl_mb
+  
+  it "should connect with TCP server" do
+    Client.connect do |cl|
+      cl.should be_instance_of(Client)
+    end
   end
-
-  it "should support function 'write single register'" do
-    @cl_mb.should_receive(:query).with("\x6\x0\x1\x0\x3").and_return("\x1\x0\x3")    
-    @cl_mb.write_single_register(0x1,0x3).should == @cl_mb
+  
+  it ":new alias :connect" do
+    Client.new do |cl|
+      cl.should be_instance_of(Client)
+    end
   end
-
-  it "should support function 'write multiple coils'" do
-    @cl_mb.should_receive(:query).with("\xf\x0\x13\x0\xa\x2\xcd\x1").and_return("\x13\x0\xa")    
-    @cl_mb.write_multiple_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]).should == @cl_mb
-  end
-
-  it "should support function 'write multiple registers'" do
-    @cl_mb.should_receive(:query).with("\x10\x0\x1\x0\x3\x6\x0\xa\x1\x2\xf\xf").and_return("\x1\x0\x3")    
-    @cl_mb.write_multiple_registers(0x1,[0x000a,0x0102, 0xf0f]).should == @cl_mb
-  end
-
-  it "should support function 'mask write register'" do
-    @cl_mb.should_receive(:query).with("\x16\x0\x4\x0\xf2\x0\2").and_return("\x4\x0\xf2\x0\x2")
-    @cl_mb.mask_write_register(0x4, 0xf2, 0x2).should == @cl_mb
-  end
-
 end

data/spec/exception_spec.rb

@@ -1,10 +1,8 @@
 require 'rmodbus'
 
-include ModBus
 include ModBus::Errors
 
 describe ModBus::TCPClient do
-
   before(:all) do
     @srv = ModBus::TCPServer.new(1502, 1)
     @srv.coils = [0] * 8
@@ -13,100 +11,101 @@ describe ModBus::TCPClient do
     @srv.input_registers = [0] * 8
     @srv.start
 
-    @cl =TCPClient.new('127.0.0.1', 1502, 1)
+    @cl = TCPClient.new('127.0.0.1', 1502)
+    @slave = @cl.with_slave(1)
   end
 
   # Read coil status
   it "should read coil status" do
-    @cl.read_coils(0, 4).should == [0] * 4
+    @slave.read_coils(0, 4).should == [0] * 4
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @cl.read_coils(501, 34) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.read_coils(501, 34) }.should raise_error(IllegalDataAddress)
   end
 
   it "should raise exception if too many data" do
-   lambda { @cl.read_coils(0, 0x07D1) }.should raise_error(IllegalDataValue)
+   lambda { @slave.read_coils(0, 0x07D1) }.should raise_error(IllegalDataValue)
   end
 
   # Read input status
   it "should read discrete inputs" do
-    @cl.read_discrete_inputs(0, 4).should == [0] * 4
+    @slave.read_discrete_inputs(0, 4).should == [0] * 4
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @cl.read_discrete_inputs(50, 23) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.read_discrete_inputs(50, 23) }.should raise_error(IllegalDataAddress)
   end
 
   it "should raise exception if too many data" do
-   lambda { @cl.read_discrete_inputs(0, 0x07D1) }.should raise_error(IllegalDataValue)
+   lambda { @slave.read_discrete_inputs(0, 0x07D1) }.should raise_error(IllegalDataValue)
   end
 
   # Read holding registers
   it "should read discrete inputs" do
-    @cl.read_holding_registers(0, 4).should == [0, 0, 0, 0]
+    @slave.read_holding_registers(0, 4).should == [0, 0, 0, 0]
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @cl.read_holding_registers(402, 99) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.read_holding_registers(402, 99) }.should raise_error(IllegalDataAddress)
   end
 
 
   it "should raise exception if too many data" do
-   lambda { @cl.read_holding_registers(0, 0x007E) }.should raise_error(IllegalDataValue)
+   lambda { @slave.read_holding_registers(0, 0x007E) }.should raise_error(IllegalDataValue)
   end
 
   # Read input registers
   it "should read discrete inputs" do
-    @cl.read_input_registers(0, 4).should == [0, 0, 0, 0]
+    @slave.read_input_registers(0, 4).should == [0, 0, 0, 0]
   end
 
   it "should raise exception if illegal data address" do
-   lambda { @cl.read_input_registers(402, 9) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.read_input_registers(402, 9) }.should raise_error(IllegalDataAddress)
   end
 
   it "should raise exception if too many data" do
-   lambda { @cl.read_input_registers(0, 0x007E) }.should raise_error(IllegalDataValue)
+   lambda { @slave.read_input_registers(0, 0x007E) }.should raise_error(IllegalDataValue)
   end
 
   # Force single coil
   it "should force single coil" do
-    @cl.write_single_coil(4, 1).should == @cl
-    @cl.read_coils(4, 4).should == [1, 0, 0, 0] 
+    @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 { @cl.write_single_coil(501, true) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.write_single_coil(501, true) }.should raise_error(IllegalDataAddress)
   end
 
   # Preset single register
   it "should preset single register" do
-    @cl.write_single_register(4, 0x0AA0).should == @cl
-    @cl.read_holding_registers(4, 1).should == [0x0AA0] 
+    @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 { @cl.write_single_register(501, 0x0AA0) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.write_single_register(501, 0x0AA0) }.should raise_error(IllegalDataAddress)
   end
 
   # Force multiple coils
   it "should force multiple coils" do
-    @cl.write_multiple_coils(4, [0,1,0,1]).should == @cl
-    @cl.read_coils(3, 5).should == [0,0,1,0,1]
+    @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 { @cl.write_multiple_coils(501, [1,0]) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.write_multiple_coils(501, [1,0]) }.should raise_error(IllegalDataAddress)
   end
 
   # Preset multiple registers
   it "should preset multiple registers" do
-    @cl.write_multiple_registers(4, [1, 2, 3, 0xAACC]).should == @cl
-    @cl.read_holding_registers(3, 5).should == [0, 1, 2, 3, 0xAACC] 
+    @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 { @cl.write_multiple_registers(501, [1, 2]) }.should raise_error(IllegalDataAddress)
+   lambda { @slave.write_multiple_registers(501, [1, 2]) }.should raise_error(IllegalDataAddress)
   end
 
   after(:all) do

data/spec/ext_spec.rb

@@ -1,7 +1,6 @@
 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]
@@ -19,5 +18,29 @@ describe Array 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" 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 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,71 +1,65 @@
 require 'rmodbus'
-
 include ModBus
 
 describe TCPClient  do
-
-  UID = 1
-
   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('')
 
-    @mb_client = TCPClient.new('127.0.0.1', 1502)
+    @slave = TCPClient.new('127.0.0.1', 1502).with_slave(@uid)
   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)
-    @mb_client.debug = true
+    @slave.debug = true
     $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]")
-    @mb_client.query(request)
+    @slave.query(request)
   end
 
   it "should don't logging if debug disable" do
     request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
     mock_query(request,response)
-    @mb_client.query(request)
+    @slave.query(request)
   end
 
-
   def mock_query(request, response)
-    @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)
+    @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
 
-describe RTUClient do
+unless RUBY_PLATFORM == "java"
+  describe RTUClient do
+    before do 
+      @sp = mock('Serial port')
+      SerialPort.should_receive(:new).with("/dev/port1", 9600, 7, 2, SerialPort::ODD).and_return(@sp)    
+      
+      @sp.stub!(:read_timeout=)
+      
+      @slave = RTUClient.new("/dev/port1", 9600, :data_bits => 7, :stop_bits => 2, :parity => SerialPort::ODD).with_slave(1)
+      @slave.read_retries = 0
+    end
     
-  before do 
-    @sp = mock('Serial port')
-    SerialPort.should_receive(:new).with("/dev/port1", 9600, 7, 2, SerialPort::ODD).and_return(@sp)    
-
-    @sp.stub!(:read_timeout=)
-
-    @mb_client = RTUClient.new("/dev/port1", 9600, 1, :data_bits => 7, :stop_bits => 2, :parity => SerialPort::ODD)
-    @mb_client.read_retries = 0
+    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(: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
-
-  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(: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")
-
-    @mb_client.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]")
-
-    @mb_client.query(request).should == "\xff\xff"
-  end
-
 end
-

data/spec/proxy_spec.rb

@@ -0,0 +1,73 @@
+require 'rmodbus'
+
+describe Array do
+  before do
+    @slave = mock('ModBus Slave')
+    @coil_proxy = ModBus::ReadWriteProxy.new(@slave, :coil)
+    @discrete_input_proxy = ModBus::ReadOnlyProxy.new(@slave, :discrete_input)
+    @holding_register_proxy = ModBus::ReadWriteProxy.new(@slave, :holding_register)
+    @input_register_proxy = ModBus::ReadOnlyProxy.new(@slave, :input_register)
+  end
+
+  # Handle all of the coil methods
+  it "should call read_coil" do
+    @slave.should_receive(:read_coil).with(0, 1)
+    @coil_proxy[0]
+  end
+  it "should call read_coils" do
+    @slave.should_receive(:read_coils).with(0, 2)
+    @coil_proxy[0..1]
+  end
+  it "should call write_coil" do
+    @slave.should_receive(:write_coil).with(0, 1)
+    @coil_proxy[0] = 1
+  end
+  it "should call write_coils" do
+    @slave.should_receive(:write_coils).with(0, [0, 0])
+    @coil_proxy[0..1] = [0, 0]
+  end
+
+
+  # Discrete input tests
+  it "should call read_discrete_input" do
+    @slave.should_receive(:read_discrete_input).with(0, 1)
+    @discrete_input_proxy[0]
+  end
+
+  it "should call read_discrete_inputs" do
+    @slave.should_receive(:read_discrete_inputs).with(0, 2)
+    @discrete_input_proxy[0..1]
+  end
+
+
+  # Holding Register Tess
+  it "should call read_holding_register" do
+    @slave.should_receive(:read_holding_register).with(0, 1)
+    @holding_register_proxy[0]
+  end
+  it "should call read_holding_registers" do
+    @slave.should_receive(:read_holding_registers).with(0, 2)
+    @holding_register_proxy[0..1]
+  end
+  it "should call write_holding_register" do
+    @slave.should_receive(:write_holding_register).with(0, 1)
+    @holding_register_proxy[0] = 1
+  end
+  it "should call write_holding_registers" do
+    @slave.should_receive(:write_holding_registers).with(0, [0, 0])
+    @holding_register_proxy[0..1] = [0, 0]
+  end
+
+
+  # Input Register Tests
+  it "should call read_discrete_input" do
+    @slave.should_receive(:read_input_register).with(0, 1)
+    @input_register_proxy[0]
+  end
+
+  it "should call read_discrete_inputs" do
+    @slave.should_receive(:read_input_registers).with(0, 2)
+    @input_register_proxy[0..1]
+  end
+end
+

data/spec/read_rtu_response_spec.rb

@@ -1,10 +1,9 @@
-require 'rmodbus/client'
-
+require 'rmodbus'
 include ModBus
 
 #Use public wrap method
-
 class Client
+  include RTU
   def test_read_method(msg)
     io = TestIO.new(msg)
     read_rtu_response(io)
@@ -85,7 +84,6 @@ describe "#read_rtu_response" do
     }
   end
 
-
   def make_resp(msg)
     "\x1" + msg + "\x2\x2" # slave + msg + mock_crc
   end

data/spec/rtu_client_spec.rb

@@ -1,22 +1,16 @@
-begin
-  require 'rubygems'
-rescue
-end
 require 'rmodbus'
-
 include ModBus
 
 describe RTUClient do
-    
   before do 
     @sp = mock('Serial port')
     SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
     @sp.stub!(:read_timeout=)
     @sp.stub!(:read)
 
-    @mb_client = RTUClient.new("/dev/port1", 9600, 1, 
-      :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
-    @mb_client.read_retries = 0
+    @cl = RTUClient.new("/dev/port1", 9600, :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
+    @slave = @cl.with_slave(1)
+    @slave.read_retries = 0
   end
 
   it "should ignore frame with other UID" do
@@ -24,7 +18,7 @@ describe RTUClient do
     @sp.should_receive(:write).with("\1#{request}\xA6\x31")
     @sp.should_receive(:read).with(2).and_return("\x2\x10")
     @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-    lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
+    lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
   end
 
   it "should ignored frame with incorrect CRC" do
@@ -32,7 +26,7 @@ describe RTUClient do
     @sp.should_receive(:write).with("\1#{request}\xA6\x31")
     @sp.should_receive(:read).with(2).and_return("\x2\x10")
     @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-    lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
+    lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
   end
   
   it "should return value of registers"do
@@ -41,18 +35,17 @@ describe RTUClient do
     @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")
-    @mb_client.query(request).should == "\xff\xff"
+    @slave.query(request).should == "\xff\xff"
   end
 
- it 'should sugar connect method' do
-    port, baud, slave = "/dev/port1", 4800, 3
+  it 'should sugar connect method' do
+    port, baud = "/dev/port1", 4800
     SerialPort.should_receive(:new).with(port, baud, 8, 1, SerialPort::NONE).and_return(@sp)    
     @sp.should_receive(:closed?).and_return(false)
     @sp.should_receive(:close)
-    RTUClient.connect(port, baud, slave) do |cl|
+    RTUClient.connect(port, baud) do |cl|
       cl.port.should == port
       cl.baud.should == baud
-      cl.slave.should == slave
       cl.data_bits.should == 8
       cl.stop_bits.should == 1
       cl.parity.should == SerialPort::NONE
@@ -61,16 +54,21 @@ describe RTUClient do
 
   it 'should have closed? method' do
     @sp.should_receive(:closed?).and_return(false)
-    @mb_client.closed?.should == false
+    @cl.closed?.should == false
 
     @sp.should_receive(:closed?).and_return(false)
     @sp.should_receive(:close)
 
-    @mb_client.close
+    @cl.close
 
     @sp.should_receive(:closed?).and_return(true)
-    @mb_client.closed?.should == 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
 

data/spec/rtu_server_spec.rb

@@ -1,5 +1,4 @@
 require 'rmodbus'
-
 include ModBus
 
 describe RTUServer do
@@ -27,5 +26,4 @@ describe RTUServer do
     @server.stop_bits.should == 2
     @server.parity.should == SerialPort::NONE
   end
-
-end
+end