sanderjd-rmodbus 0.1.3 → 0.2.0

data/lib/rmodbus/tcp_server.rb

@@ -0,0 +1,160 @@
+# RModBus - free implementation of ModBus protocol on Ruby.
+#
+# Copyright (C) 2008  Timin Aleksey
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# 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 'gserver'
+
+
+module ModBus
+	
+	class TCPServer < GServer
+    
+    attr_accessor :coils, :discret_inputs, :holding_registers, :input_registers
+
+    @@funcs = [1,2,3,4,5,6,15,16]
+    
+    def initialize(port = 502, uid = 1)
+      @coils = []
+      @discret_inputs = []
+      @holding_registers =[]
+      @input_registers = []
+      @uid = uid
+      super(port)
+    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
+          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
+        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
+
+    def parse_read_func(req, field)
+      quant = req[3,2].to_int16
+
+      return { :err => 3} unless quant <= 0x7d
+        
+      addr = req[1,2].to_int16
+      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].to_int16
+      return { :err => 2 } unless addr <= @coils.size
+
+      val = req[3,2].to_int16
+      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].to_int16
+      return { :err => 2 } unless addr <= @coils.size
+
+      val = req[3,2].to_int16
+
+      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]].to_array_bit }
+      end
+      param
+    end
+
+    def parse_write_multiple_registers_func(req)
+      param = parse_read_func(req, @holding_registers)
+
+      if param[:err] == 0
+        # Each val is 2 bytes, so multiply by two to get number of bytes
+        bytes_for_vals = param[:quant] * 2
+        param = {:err => 0, :addr => param[:addr], :quant => param[:quant], :val => req[6,bytes_for_vals].to_array_int16 }
+      end
+      param
+    end
+
+	end
+end

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/rtu_client_spec.rb

@@ -0,0 +1,13 @@
+require 'rmodbus/rtu_client'
+
+include ModBus
+
+describe RTUClient do
+
+  before do
+    @mb_cl = RTUClient.new(1, 9600, UID)
+  end
+
+ # it "should 
+
+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,107 @@
+require '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
+    socket = TCPSocket.new('127.0.0.1', 8502)
+    begin
+      socket.write "\0\0\1\0\0\6\1"
+    rescue ModBus::Errors::ModBusException => ex
+      ex.message.should == "Server did not respond"
+    rescue
+      # Fails if it is whiny about anything else
+      assert false
+    ensure
+      socket.close
+    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
+
+  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: sanderjd-rmodbus
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - Aleksey Timin
@@ -19,12 +19,28 @@ description: A free Ruby implementation of the ModBus protocol
 email: sanderjd@gmail.com
 executables: []
 
-extensions: 
-- ext/extconf.rb
+extensions: []
+
 extra_rdoc_files: []
 
 files: 
-- ext/extconf.rb
+- VERSION.yml
+- AUTHORS
+- CHANGES
+- LICENSE
+- README
+- Rakefile
+- lib/rmodbus
+- lib/rmodbus/client.rb
+- lib/rmodbus/exceptions.rb
+- lib/rmodbus/tcp_client.rb
+- lib/rmodbus/tcp_server.rb
+- lib/rmodbus.rb
+- spec/client_spec.rb
+- spec/ext_spec.rb
+- spec/rtu_client_spec.rb
+- spec/tcp_client_spec.rb
+- spec/tcp_server_spec.rb
 has_rdoc: true
 homepage: http://rubyforge.org/var/svn/rmodbus/trunk
 post_install_message: