rmodbus-ccutrer 2.0.0

data/lib/rmodbus/tcp_slave.rb

@@ -0,0 +1,55 @@
+module ModBus
+  # TCP slave implementation
+  # @example
+  #   TCP.connect('127.0.0.1', 10002) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see TCP#open_tcp_connection
+  # @see Client#with_slave
+  # @see Slave
+  class TCPSlave < Client::Slave
+    attr_reader :transaction
+
+    # @see Slave::initialize
+    def initialize(uid, io)
+      @transaction = 0
+      super(uid, io)
+    end
+
+    private
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+    def send_pdu(pdu)
+      @transaction = 0 if @transaction.next > 65535
+      @transaction += 1
+      msg = @transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @uid.chr + pdu
+      @io.write msg
+
+      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+    end
+
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+    def read_pdu
+      loop do
+        header = @io.read(7)
+        if header
+          trn = header[0,2].unpack('n')[0]
+          len = header[4,2].unpack('n')[0]
+          msg = @io.read(len-1)
+
+          log "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg)
+
+          if trn == @transaction
+            return msg
+          else
+            log "Transaction number mismatch. A packet is ignored."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rmodbus/version.rb

@@ -0,0 +1,3 @@
+module ModBus
+  VERSION = '2.0.0'
+end

data/spec/client_spec.rb

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

@@ -0,0 +1,120 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+describe ModBus::TCPClient do
+  before(:all) do
+    @srv = ModBus::TCPServer.new(1502)
+    srv_slave = @srv.with_slave(1)
+    srv_slave.coils = [0] * 8
+    srv_slave.discrete_inputs = [0] * 8
+    srv_slave.holding_registers = [0] * 8
+    srv_slave.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

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

@@ -0,0 +1,89 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+describe ModBus::TCPClient  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('')
+
+    @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

data/spec/proxy_spec.rb

@@ -0,0 +1,74 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+describe Array do
+  before do
+    @slave = double('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
+