rmodbus-ccutrer 2.0.0

data/spec/read_rtu_response_spec.rb

@@ -0,0 +1,92 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+#Use public wrap method
+class ModBus::Client
+  include ModBus::RTU
+  def test_read_method(msg)
+    io = TestIO.new(msg)
+    read_rtu_response(io)
+  end
+
+end
+
+class TestIO
+  def initialize(msg)
+    @msg = msg
+  end
+
+  def read(num)
+    result = @msg[0,num]
+    @msg = @msg[num..-1]
+    result
+  end
+end
+
+describe "#read_rtu_response" do
+  before do
+    @cl_mb = ModBus::Client.new   
+  end
+
+  it "should read response for 'read coils'" do
+    resp = make_resp("\x1\x3\xcd\x6b\x05")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'read discrete inputs'" do
+    resp = make_resp("\x2\x3\xac\xdb\x35")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'read holding registers'" do
+    resp = make_resp("\x3\x6\x2\x2b\x0\x0\x0\x64")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'read input registers'" do
+    resp = make_resp("\x4\x2\x0\xa")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write single coil'" do
+    resp = make_resp("\x5\x0\xac\xff\x0")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write single register'" do
+    resp = make_resp("\x6\x0\x1\x0\x3")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write multiple coils'" do
+    resp = make_resp("\xf\x0\x13\x0\xa")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response for 'write multiple registers'" do
+    resp = make_resp("\x10\x0\x1\x0\x2")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read response 'mask write register'" do
+    resp = make_resp("\x16\x0\x4\x0\xf2\x0\x25")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should read exception codes" do
+    resp = make_resp("\x84\x3")
+    @cl_mb.test_read_method(resp).should == resp 
+  end
+
+  it "should raise exception if function is illegal" do
+    resp =  make_resp("\x1f\x0\x1\x0\x2")
+    lambda{ @cl_mb.test_read_method(resp)}.should raise_error {
+      ModBus::Errors::IllegalFunction
+    }
+  end
+
+  def make_resp(msg)
+    "\x1" + msg + "\x2\x2" # slave + msg + mock_crc
+  end
+end
+

data/spec/response_mismach_spec.rb

@@ -0,0 +1,163 @@
+# -*- coding: ascii
+require "spec_helper"
+
+describe "response mismach" do
+  include RaiseResponseMatcher
+  before(:each) do
+    @slave = ModBus::Client::Slave.new(1, nil)
+    @slave.raise_exception_on_mismatch = true
+  end
+
+  it "should raise error if function code is mismatch" do
+    request = "\x1\x0\x13\x0\x12"
+    response = "\x2\x3\xcd\xb6\x5"
+    mock_query!(request, response)
+
+    lambda{ @slave.read_coils(0x13,0x12) }.should raise_response_mismatch(
+      "Function code is mismatch (expected 1, got 2)",
+      request, response)
+  end
+
+  describe "read coils" do
+    it "should raise error if count of byte is mismatch" do
+      request = "\x1\x0\x13\x0\x12"
+      response = "\x1\x2\xcd\xb6"
+      mock_query!(request, response)
+
+      lambda{ @slave.read_coils(0x13,0x12) }.should raise_response_mismatch(
+        "Byte count is mismatch (expected 3, got 2 bytes)",
+        request, response)
+    end
+  end
+
+  describe "read discrete inputs" do
+    it "should raise error if count of byte is mismatch" do
+      request = "\x2\x0\x13\x0\x12"
+      response = "\x2\x2\xcd\xb6"
+      mock_query!(request, response)
+
+      lambda{ @slave.read_discrete_inputs(0x13,0x12) }.should raise_response_mismatch(
+        "Byte count is mismatch (expected 3, got 2 bytes)",
+        request, response)
+    end
+  end
+
+  describe "read holding registesrs" do
+    it "should raise error if count of registers is mismatch" do
+      request = "\x3\x0\x8\x0\x1"
+      response = "\x3\x4\x0\xa\x0\xb"
+      mock_query!(request, response)
+
+      lambda{ @slave.read_holding_registers(0x8,0x1) }.should raise_response_mismatch(
+        "Register count is mismatch (expected 1, got 2 regs)",
+        request, response)
+    end
+  end
+
+  describe "read input registesrs" do
+    it "should raise error if count of registers is mismatch" do
+      request = "\x4\x0\x8\x0\x2"
+      response = "\x4\x2\xa\x0"
+      mock_query!(request, response)
+
+      lambda{ @slave.read_input_registers(0x8,0x2) }.should raise_response_mismatch(
+        "Register count is mismatch (expected 2, got 1 regs)",
+        request, response)
+    end
+  end
+
+  describe "write single coil" do
+    it "should raise error if address of coil is mismatch" do
+      request = "\x5\x0\x8\xff\x0"
+      response = "\x5\x0\x9\xff\x0"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_coil(8,true) }.should raise_response_mismatch(
+        "Address is mismatch (expected 8, got 9)",
+        request, response)
+    end
+
+    it "should raise error if value of coil is mismatch" do
+      request = "\x5\x0\x8\xff\x0"
+      response = "\x5\x0\x8\x0\x0"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_coil(8,true) }.should raise_response_mismatch(
+        "Value is mismatch (expected 0xff00, got 0x0)",
+        request, response)
+    end
+  end
+
+  describe "write single register" do
+    it "should raise error if address of register is mismatch" do
+      request = "\x6\x0\x8\xa\xb"
+      response = "\x6\x0\x9\xa\xb"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_single_register(8,0x0a0b) }.should raise_response_mismatch(
+        "Address is mismatch (expected 8, got 9)",
+        request, response)
+    end
+
+    it "should raise error if value of register is mismatch" do
+      request = "\x6\x0\x8\xa\xb"
+      response = "\x6\x0\x8\x9\xb"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_single_register(8,0x0a0b) }.should raise_response_mismatch(
+        "Value is mismatch (expected 0xa0b, got 0x90b)",
+        request, response)
+    end
+  end
+
+  describe "write multiple coils" do
+    it "should raise error if address of first coil is mismatch" do
+      request = "\xf\x0\x13\x0\xa\2\xcd\x01"
+      response = "\xf\x0\x14\x0\xa"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]) }.should raise_response_mismatch(
+        "Address is mismatch (expected 19, got 20)",
+        request, response)
+   end
+
+   it "should raise error if quantity of coils is mismatch" do
+      request = "\xf\x0\x13\x0\xa\2\xcd\x01"
+      response = "\xf\x0\x13\x0\x9"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]) }.should raise_response_mismatch(
+        "Quantity is mismatch (expected 10, got 9)",
+        request, response)
+    end
+  end
+
+  describe "write multiple registers" do
+    it "should raise error if address of first register is mismatch" do
+      request = "\x10\x0\x1\x0\x2\x4\x0\xa\x1\x2"
+      response = "\x10\x0\x2\x0\x2"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_holding_registers(0x1,[0xa,0x102]) }.should raise_response_mismatch(
+        "Address is mismatch (expected 1, got 2)",
+        request, response)
+   end
+
+   it "should raise error if quantity of registers is mismatch" do
+      request = "\x10\x0\x1\x0\x2\x4\x0\xa\x1\x2"
+      response = "\x10\x0\x2\x0\x1"
+      mock_query!(request, response)
+
+      lambda{ @slave.write_holding_registers(0x1,[0xa,0x102]) }.should raise_response_mismatch(
+        "Quantity is mismatch (expected 2, got 1)",
+        request, response)
+    end
+  end
+
+
+  private
+  def mock_query!(request, response)
+    @slave.should_receive(:send_pdu).with(request)
+    @slave.should_receive(:read_pdu).and_return(response)
+  end
+end

data/spec/rtu_client_spec.rb

@@ -0,0 +1,86 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+describe ModBus::RTUClient do
+  before do 
+    @sp = double('Serial port')
+
+    SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
+    SerialPort.stub(:public_method_defined?).with(:flush_input).and_return(true)
+
+    @sp.stub(:read_timeout=)
+    @sp.stub(:class).and_return(SerialPort)
+    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
+    @sp.stub(:flush_input)
+
+    @cl = ModBus::RTUClient.new("/dev/port1", 9600, :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
+    @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" 
+    @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 {@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" 
+    @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 {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
+  end
+  
+  it "should return value of registers"do
+    request = stab_valid_request
+    @slave.query(request).should == "\xff\xff"
+  end
+
+  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)
+    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
+    ModBus::RTUClient.connect(port, baud) do |cl|
+      cl.port.should == port
+      cl.baud.should == baud
+      cl.data_bits.should == 8
+      cl.stop_bits.should == 1
+      cl.parity.should == SerialPort::NONE
+    end
+  end
+
+  it 'should have closed? method' do
+    @sp.should_receive(:closed?).and_return(false)
+    @cl.closed?.should == false
+
+    @sp.should_receive(:closed?).and_return(false)
+    @sp.should_receive(:close)
+
+    @cl.close
+
+    @sp.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
+
+  def stab_valid_request
+    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")
+
+    request
+  end
+end
+

data/spec/rtu_server_spec.rb

@@ -0,0 +1,31 @@
+# -*- 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

@@ -0,0 +1,76 @@
+# -*- 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