rmodbus 0.3.1 → 0.4.0

data/lib/rmodbus/tcp_server.rb

@@ -11,21 +11,30 @@
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-require 'rmodbus/exceptions'
+require 'rmodbus/parsers'
 require 'gserver'
 
 
 module ModBus
-	
   class TCPServer < GServer
+    include Parsers
     
-    attr_accessor :coils, :discret_inputs, :holding_registers, :input_registers
+    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers
 
-    Funcs = [1,2,3,4,5,6,15,16]
-    
+    def discret_inputs
+      warn "[DEPRECATION] `discret_inputs` is deprecated.  Please use `discrete_inputs` instead."
+      @discrete_inputs 
+    end
+  
+    def discret_inputs=(val)
+      warn "[DEPRECATION] `discret_inputs=` is deprecated.  Please use `discrete_inputs=` instead."
+      @discrete_inputs=val
+    end
+  
+   
     def initialize(port = 502, uid = 1)
       @coils = []
-      @discret_inputs = []
+      @discrete_inputs = []
       @holding_registers =[]
       @input_registers = []
       @uid = uid
@@ -44,119 +53,10 @@ module ModBus
         len = req[4,2].unpack('n')[0]
         req = io.read(len - 1)
 
-        func = req.getbyte(0)
+        pdu = exec_req(req, @coils, @discrete_inputs, @holding_registers, @input_registers)
 
-        unless Funcs.include?(func)
-          param = { :err => 1 }
-        end
-      
-        case func
-          when 1
-            param = parse_read_func(req, @coils)
-            if param[:err] == 0
-              val = @coils[param[:addr],param[:quant]].pack_to_word
-              res = func.chr + val.size.chr + val
-            end
-          when 2
-            param = parse_read_func(req, @discret_inputs)
-            if param[:err] == 0
-              val = @discret_inputs[param[:addr],param[:quant]].pack_to_word
-              res = func.chr + val.size.chr + val
-            end
-          when 3
-            param = parse_read_func(req, @holding_registers)
-            if param[:err] == 0
-              res = func.chr + (param[:quant] * 2).chr + @holding_registers[param[:addr],param[:quant]].pack('n*')
-            end
-          when 4
-            param = parse_read_func(req, @input_registers)
-            if param[:err] == 0
-              res = func.chr + (param[:quant] * 2).chr + @input_registers[param[:addr],param[:quant]].pack('n*')
-            end
-          when 5 
-            param = parse_write_coil_func(req)
-            if param[:err] == 0
-              @coils[param[:addr]] = param[:val]
-              res = func.chr + req
-            end
-          when 6
-            param = parse_write_register_func(req)
-            if param[:err] == 0
-              @holding_registers[param[:addr]] = param[:val]
-              res = func.chr + req
-            end
-          when 15
-            param = parse_write_multiple_coils_func(req)
-            if param[:err] == 0
-              @coils[param[:addr],param[:quant]] = param[:val][0,param[:quant]]
-              res = func.chr + req
-            end
-          when 16
-            param = parse_write_multiple_registers_func(req)
-            if param[:err] == 0
-              @holding_registers[param[:addr],param[:quant]] = param[:val][0,param[:quant]]
-              res = func.chr + req
-            end
-        end
-        if param[:err] ==  0
-          resp = tr + "\0\0" + (res.size + 1).to_word + @uid.chr + res
-        else
-          resp = tr + "\0\0\0\3" + @uid.chr + (func | 0x80).chr + param[:err].chr
-        end 
-        io.write resp
-      end
+        io.write tr + "\0\0" + (pdu.size + 1).to_word + @uid.chr + pdu
     end
-
-    private
-
-    def parse_read_func(req, field)
-      quant = req[3,2].unpack('n')[0]
-
-      return { :err => 3} unless quant <= 0x7d
-        
-      addr = req[1,2].unpack('n')[0]
-      return { :err => 2 } unless addr + quant <= field.size
-        
-      return { :err => 0, :quant => quant, :addr => addr }    
-    end
-
-    def parse_write_coil_func(req)
-      addr = req[1,2].unpack('n')[0]
-      return { :err => 2 } unless addr <= @coils.size
-
-      val = req[3,2].unpack('n')[0]
-      return { :err => 3 } unless val == 0 or val == 0xff00
-      
-      val = 1 if val == 0xff00
-      return { :err => 0, :addr => addr, :val => val }  
     end
-
-    def parse_write_register_func(req)
-      addr = req[1,2].unpack('n')[0]
-      return { :err => 2 } unless addr <= @coils.size
-
-      val = req[3,2].unpack('n')[0]
-
-      return { :err => 0, :addr => addr, :val => val }  
-	  end
-
-    def parse_write_multiple_coils_func(req)
-      param = parse_read_func(req, @coils)
-
-      if param[:err] == 0
-        param = {:err => 0, :addr => param[:addr], :quant => param[:quant], :val => req[6,param[:quant]].unpack_bits }
-      end
-      param
-    end
-
-    def parse_write_multiple_registers_func(req)
-      param = parse_read_func(req, @holding_registers)
-
-      if param[:err] == 0
-        param = {:err => 0, :addr => param[:addr], :quant => param[:quant], :val => req[6,param[:quant] * 2].unpack('n*')}
-      end
-      param
-    end
-
-	end
+  end
 end

data/lib/rmodbus.rb

@@ -12,4 +12,5 @@
 require 'rmodbus/tcp_client'
 require 'rmodbus/tcp_server'
 require 'rmodbus/rtu_client'
+require 'rmodbus/rtu_server'
 

data/spec/exception_spec.rb

@@ -0,0 +1,117 @@
+require 'rmodbus'
+
+include ModBus
+include ModBus::Errors
+
+describe ModBus::TCPClient do
+
+  before(:all) do
+    @srv = ModBus::TCPServer.new(1502, 1)
+    @srv.coils = [0] * 8
+    @srv.discrete_inputs = [0] * 8
+    @srv.holding_registers = [0] * 8
+    @srv.input_registers = [0] * 8
+    @srv.start
+
+    @cl =TCPClient.new('127.0.0.1', 1502, 1)
+  end
+
+  # Read coil status
+  it "should read coil status" do
+    @cl.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)
+  end
+
+  it "should raise exception if too many data" do
+   lambda { @cl.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
+  end
+
+  it "should raise exception if illegal data address" do
+   lambda { @cl.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)
+  end
+
+  # Read holding registers
+  it "should read discrete inputs" do
+    @cl.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)
+  end
+
+
+  it "should raise exception if too many data" do
+   lambda { @cl.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]
+  end
+
+  it "should raise exception if illegal data address" do
+   lambda { @cl.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)
+  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] 
+  end
+
+  it "should raise exception if illegal data address" do
+   lambda { @cl.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] 
+  end
+
+  it "should raise exception if illegal data address" do
+   lambda { @cl.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]
+  end
+
+  it "should raise exception if illegal data address" do
+   lambda { @cl.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] 
+  end
+
+  it "should raise exception if illegal data address" do
+   lambda { @cl.write_multiple_registers(501, [1, 2]) }.should raise_error(IllegalDataAddress)
+  end
+
+  after(:all) do
+    @cl.close unless @cl.closed?
+    @srv.stop
+  end
+
+end

data/spec/ext_spec.rb

@@ -7,7 +7,11 @@ describe Array do
   end
 
   it "should return string reprisent 16bit" do
-    @arr.pack_to_word == "\xcd\x6b\x5" 
+    @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
 
 end

data/spec/logging_spec.rb

@@ -0,0 +1,69 @@
+require 'rmodbus'
+
+include ModBus
+
+describe TCPClient  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 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
+    STDOUT.should_receive("<<").with("Tx (12 bytes): [00][01][00][00][00][06][01][03][00][6b][00][03]\n")
+    STDOUT.should_receive("<<").with("Rx (15 bytes): [00][01][00][00][00][09][01][03][06][02][2b][00][00][00][64]\n")
+    @mb_client.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)
+  end
+
+
+  def mock_query(request, response)
+    @adu = TCPClient.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
+    
+  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
+  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).and_return("\x1\x3\x2\xff\xff\xb9\xf4")
+
+    @mb_client.debug = true
+    STDOUT.should_receive("<<").with("Tx (8 bytes): [01][03][00][01][00][01][d5][ca]\n")
+    STDOUT.should_receive("<<").with("Rx (7 bytes): [01][03][02][ff][ff][b9][f4]\n")
+
+    @mb_client.query(request).should == "\xff\xff"
+  end
+
+end
+

data/spec/rtu_client_spec.rb

@@ -9,33 +9,63 @@ include ModBus
 describe RTUClient do
     
   before do 
-    @port = mock('Serial port')
-    SerialPort.should_receive(:new).with("/dev/port1", 9600).and_return(@port)    
-    @port.stub!(:read_timeout=)
-    @mb_client = RTUClient.new("/dev/port1", 9600, 1)
+    @sp = mock('Serial port')
+    SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
+    @sp.stub!(:read_timeout=)
+
+    @mb_client = RTUClient.new("/dev/port1", 9600, 1, 
+      :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
     @mb_client.read_retries = 0
   end
 
   it "should ignore frame with other UID" do
     request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-    @port.should_receive(:write).with("\1#{request}\xA6\x31")
-    @port.should_receive(:read).and_return("\x2\x10\x0\x1\x0\x1\x1C\x08")
+    @sp.should_receive(:write).with("\1#{request}\xA6\x31")
+    @sp.should_receive(:read).and_return("\x2\x10\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" 
-    @port.should_receive(:write).with("\1#{request}\xA6\x31")
-    @port.should_receive(:read).and_return("\x1\x10\x0\x1\x0\x1\x1C\x08")
+    @sp.should_receive(:write).with("\1#{request}\xA6\x31")
+    @sp.should_receive(:read).and_return("\x1\x10\x0\x1\x0\x1\x1C\x08")
     lambda {@mb_client.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
   end
   
   it "should return value of registers"do
     request = "\x3\x0\x1\x0\x1"
-    @port.should_receive(:write).with("\1#{request}\xd5\xca")
-    @port.should_receive(:read).and_return("\x1\x3\x2\xff\xff\xb9\xf4")
+    @sp.should_receive(:write).with("\1#{request}\xd5\xca")
+    @sp.should_receive(:read).and_return("\x1\x3\x2\xff\xff\xb9\xf4")
     @mb_client.query(request).should == "\xff\xff"
   end
 
+ it 'should sugar connect method' do
+    port, baud, slave = "/dev/port1", 4800, 3
+    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|
+      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
+    end
+  end
+
+  it 'should have closed? method' do
+    @sp.should_receive(:closed?).and_return(false)
+    @mb_client.closed?.should == false
+
+    @sp.should_receive(:closed?).and_return(false)
+    @sp.should_receive(:close)
+
+    @mb_client.close
+
+    @sp.should_receive(:closed?).and_return(true)
+    @mb_client.closed?.should == true
+  end
+
 end
 

data/spec/rtu_server_spec.rb

@@ -0,0 +1,31 @@
+require 'rmodbus'
+
+include ModBus
+
+describe RTUServer do
+  before do
+    @sp = mock "SerialPort"
+    SerialPort.should_receive(:new).with('/dev/ttyS0', 4800, 7, 2, SerialPort::NONE).and_return(@sp)
+    @sp.stub!(:read_timeout=)
+
+    @server = RTUServer.new('/dev/ttyS0', 4800, 1, :data_bits => 7, :stop_bits => 2)
+    @server.coils = [1,0,1,1]
+    @server.discrete_inputs = [1,1,0,0]
+    @server.holding_registers = [1,2,3,4]
+    @server.input_registers = [1,2,3,4]
+  end
+
+  it "should be valid initialized " do
+    @server.coils.should == [1,0,1,1]
+    @server.discrete_inputs.should == [1,1,0,0]
+    @server.holding_registers.should == [1,2,3,4]
+    @server.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