rmodbus 0.2 → 0.2.1

data/lib/rmodbus/tcp_client.rb

@@ -27,11 +27,11 @@ module ModBus
 
     # Connect with a ModBus server
     def initialize(ipaddr, port = 502, slaveaddr = 1)
-      
+      @ipaddr, @port = ipaddr, port
       tried = 0
       begin
         timeout(1, ModBusTimeout) do
-        @sock = TCPSocket.new(ipaddr, port)
+        @sock = TCPSocket.new(@ipaddr, @port)
       end
       rescue ModBusTimeout => err
         tried += 1
@@ -44,7 +44,6 @@ module ModBus
     def close
       @sock.close unless @sock.closed?
     end
- 
 
     def self.transaction 
       @@transaction
@@ -56,7 +55,7 @@ module ModBus
       @sock.write @@transaction.to_bytes + "\0\0" + (pdu.size + 1).to_bytes + @slave.chr + pdu
     end
 
-    def read_pdu     
+    def read_pdu    
       header = @sock.read(7)            
       if header
         tin = header[0,2].to_int16

data/lib/rmodbus/tcp_server.rb

@@ -21,7 +21,9 @@ module ModBus
     
     attr_accessor :coils, :discret_inputs, :holding_registers, :input_registers
 
-    @@funcs = [1,2,3,4,5,6,15,16]
+
+
+    Funcs = [1,2,3,4,5,6,15,16]
     
     def initialize(port = 502, uid = 1)
       @coils = []
@@ -33,74 +35,89 @@ module ModBus
     end
 
     def serve(io)
-      req = io.read(7)
-      if req[2,2] != "\x00\x00" or req[6].to_i != @uid
-        io.close
-        return
-      end
-
-      tr = req[0,2]
-      len = req[4,2].to_int16
-      req = io.read(len - 1)
-      func = req[0].to_i
-
-      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]].bits_to_bytes
-            res = func.chr + val.size.chr + val
+      loop do
+        req = io.read(7)
+        if RUBY_VERSION.to_f == 1.9
+          if req[2,2] != "\x00\x00" or req.getbyte(6) != @uid
+            io.close
+            break
           end
-        when 2
-          param = parse_read_func(req, @discret_inputs)
-          if param[:err] == 0
-            val = @discret_inputs[param[:addr],param[:quant]].bits_to_bytes
-            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]].to_ints16
-          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]].to_ints16
-          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
+        else
+          if req[2,2] != "\x00\x00" or req[6].to_i != @uid
+            io.close
+            break
           end
+        end
+ 
+        tr = req[0,2]
+        len = req[4,2].to_int16
+        req = io.read(len - 1)
+
+        if RUBY_VERSION.to_f == 1.9
+          func = req.getbyte(0)
+        else
+          func = req[0].to_i
+        end
+
+        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]].bits_to_bytes
+              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]].bits_to_bytes
+              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]].to_ints16
+            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]].to_ints16
+            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_bytes + @uid.chr + res
+        else
+          resp = tr + "\0\0\0\3" + @uid.chr + (func | 0x80).chr + param[:err].chr
+        end 
+        io.write resp
       end
-      if param[:err] ==  0
-        io.write tr + "\0\0" + (res.size + 1).to_bytes + @uid.chr + res
-      else
-        io.write tr + "\0\0\0\3" + @uid.chr + (func | 0x80).chr + param[:err].chr
-      end 
     end
 
     private

data/spec/client_spec.rb

@@ -0,0 +1,57 @@
+require 'rmodbus/client'
+
+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]
+  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]
+  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]
+  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
+  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
+  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/ext_spec.rb

@@ -0,0 +1,27 @@
+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]
+  end
+
+  it "should return string reprisent 16bit" do
+    @arr.bits_to_bytes.should == "\xcd\x6b\x5" 
+  end
+
+  it "should return string reprisent 16ints" do
+    @arr = [1,2] 
+    @arr.to_ints16 == "\x0\x1\x0\x2"
+  end
+
+end
+
+describe String do
+
+  it "should return array of int16" do
+    @str = "\x1\x2\x3\x4\x5\x6"
+    @str.to_array_int16.should == [0x102, 0x304, 0x506]
+  end
+
+end

data/spec/tcp_client_spec.rb

@@ -0,0 +1,48 @@
+require 'rmodbus/tcp_client'
+
+include ModBus
+
+describe TCPClient, "method 'query'"  do
+
+  UID = 1
+
+  before 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] = TCPClient.transaction.next.to_bytes
+    @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] = TCPClient.transaction.next.to_bytes
+    @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
+    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 = TCPClient.transaction.next.to_bytes + "\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
+
+end

data/spec/tcp_server_spec.rb

@@ -0,0 +1,106 @@
+require 'lib/rmodbus'
+
+describe TCPServer do
+  
+  before do
+    @server = ModBus::TCPServer.new(8502,1)
+    @server.coils = [1,0,1,1]
+    @server.discret_inputs = [1,1,0,0]
+    @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)
+  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"
+    end
+  end
+
+  it "should silent if protocol identifer has mismatched" do
+    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
+  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 
+  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
+  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
+  end
+
+  it "should supported function 'read coils'" do
+    @client.read_coils(0,3).should == @server.coils[0,3]
+  end
+
+  after do
+    @server.stop
+  end
+
+  it "should supported function 'read discrete inputs'" do
+    @client.read_discrete_inputs(1,3).should == @server.discret_inputs[1,3]
+  end
+
+  it "should supported function 'read holding registers'" do
+    @client.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]
+  end
+
+  it "should supported function 'write single coil'" do
+    @server.coils[3] = 0
+    @client.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)
+    @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])
+    @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])
+    @server.holding_registers.should == [1,2,3,1,2,3,4,5,9]
+  end
+
+  after do
+    @client.close if @client
+    @server.stop if @server
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rmodbus
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: 0.2.1
 platform: ruby
 authors: 
 - A.Timin, J. Sanders
@@ -9,7 +9,7 @@ autorequire: rmodbus
 bindir: bin
 cert_chain: []
 
-date: 2009-01-30 00:00:00 +05:00
+date: 2009-02-09 00:00:00 +05:00
 default_executable: 
 dependencies: []
 
@@ -25,14 +25,17 @@ extra_rdoc_files:
 - LICENSE
 - CHANGES
 files: 
-- lib/rmodbus/rtu_client.rb
 - lib/rmodbus/tcp_server.rb
 - lib/rmodbus/client.rb
 - lib/rmodbus/exceptions.rb
 - lib/rmodbus/tcp_client.rb
 - lib/rmodbus.rb
-- ext/extconf.rb
-- ext/serialport.c
+- examples/add_new_function.rb
+- examples/use_tcp_modbus.rb
+- spec/client_spec.rb
+- spec/tcp_client_spec.rb
+- spec/tcp_server_spec.rb
+- spec/ext_spec.rb
 - README
 - AUTHORS
 - LICENSE