rmodbus 0.2.3 → 0.3.0

data/ChangeLog

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+2009-03-5 Timin Aleksey <atimin@gmail.com>
+	* lib/rmodbus/ext.rb: Added.
+	* lib/rmodbus/*.rb, spec/*_spec.rb: Have done
+	refactoring. Now using pack\unpack methods.
+	* CHANGES: Delete.
+	* ChageLog: Start new log of shanges.
+
+2009-03-6 Timin Aleksey <atimin@gmail.com>
+	* lib/rmodbus/rtu_client.rb, spec/rtu_client_spec.rb: Have completed to
+	design of ModBus::RTUClient class.
+
+2009-04-17 James Sanders <sanderjd@gmail.com>
+    * lib/rmodbus/exceptions.rb: Inherit from StandardError instead of
+	Exception
+2010-01-7 Timin Aleksey <atimin@gmail.com>
+	* lib/rmodbus/tcp_client.rb: Fixed bug of overflow transaction counter (thanks
+	Tallak Tveide)
+

data/README

@@ -4,8 +4,8 @@
 
 == Feature
 
-* Client ModBus-TCP
-* Server ModBus-TCP
+* Client\Server ModBus-TCP
+* Client ModBus-RTU (experimental) with serialport gem
 * Support functions:
   * 01 (0x01) Read Coils
   * 02 (0x02) Read Discrete Inputs
@@ -15,6 +15,7 @@
   * 06 (0x06) Write Single Register
   * 15 (0x0F) Write Multiple Coils
   * 16 (0x10) Write Multiple registers
+  * 22 (0x16) Mask Write register 
 
 == Installation
 
@@ -30,21 +31,18 @@ Download and install RModBus with the following
 
 $ gem install --remote rmodbus
 
-== CSM
+== GitHub 
 
-You can checkout source code from SVN  repositry 
+You can checkout source code from GitHub repositry 
 
-
-$ svn checkout svn://rubyforge.org/var/svn/rmodbu/trunk
-
-or
-
-$ svn checkout http://rubyforge.org/var/svn/rmodbus/trunk
+$ git clone git://github.com/flipback/RModBus.git
 
 == Reference 
 
 RModBus project: http://rubyforge.org/projects/rmodbus
 
+RModBud on GitHub: http://github.com/flipback/RModBus
+
 ModBus community: http://www.modbus-ida.org
 
 

data/lib/rmodbus/client.rb

@@ -13,113 +13,8 @@
 # GNU General Public License for more details.
 
 require 'rmodbus/exceptions'
+require 'rmodbus/ext'
 
-class String
-
-
-  if RUBY_VERSION.to_f == 1.9
-    def to_array_int16
-      array_int16 = []
-      i = 0
-      while(i < self.bytesize) do
-        array_int16 << self.getbyte(i) * 256 + self.getbyte(i+1)
-        i += 2
-      end
-      array_int16
-    end
-
-    def to_array_bytes
-      array_bytes = []
-      self.each_byte do |b|
-        array_bytes << b
-      end
-      array_bytes
-    end
-    
-    def to_int16
-        self.getbyte(0)*256 + self.getbyte(1)
-    end
-
-  else
-    def to_array_int16
-      array_int16 = []
-      i = 0
-      while(i < self.size) do
-        array_int16 << (self[i].to_i)*256 + self[i+1].to_i
-        i += 2
-      end
-      array_int16
-    end
-
-    def to_array_bytes
-      array_bytes = []
-      i = 0
-      while(i<self.size) do
-        array_bytes << self[i].to_i
-        i += 1
-      end
-      array_bytes
-    end
-
-    def to_int16
-        self[0]*256 + self[1]
-    end
-  end  
-    
-
-  def to_array_bit
-    array_bit = []
-    self.each_byte do |byte|
-      mask = 0x01 
-      8.times {
-        unless (mask & byte) == 0
-          array_bit << 1
-        else
-          array_bit << 0
-        end
-        mask = mask << 1
-      }
-    end
-    array_bit
-  end
-
-end
-
-class Integer
-  def to_bytes
-    (self >> 8).chr + (self & 0xff).chr 
-  end
-end
-
-class Array
-
-  def to_ints16
-    s = ""
-    self.each do |int16|
-      s << int16.to_bytes
-    end
-    s
-  end
-
-  def bits_to_bytes
-    int16 = 0
-    s = ""
-    mask = 0x01
-
-    self.each do |bit| 
-      int16 |= mask if bit > 0
-      mask <<= 1
-      if mask  == 0x100
-        mask = 0x01
-        s << int16.chr
-        int16 = 0
-      end
-    end
-    s << int16.chr unless mask == 0x01
-    s
-  end
-
-end
 
 module ModBus
 
@@ -127,21 +22,23 @@ module ModBus
   
     include Errors
     # Number of times to retry on connection and read timeouts
-    CONNECTION_RETRIES = 3
-    READ_RETRIES = 3 
+    attr_accessor :connection_retries, :read_retries
 
+    def initialize
+      @connection_retries = 10
+      @read_retries = 10
+    end
     # Read value *ncoils* coils starting with *addr*
-    #
     # Return array of their values
     def read_coils(addr, ncoils)
-      query("\x1" + addr.to_bytes + ncoils.to_bytes).to_array_bit[0..ncoils-1]
+      query("\x1" + addr.to_word + ncoils.to_word).unpack_bits[0..ncoils-1]
     end
 
     # Read value *ncoils* discrete inputs starting with *addr*
     #
     # Return array of their values
     def read_discrete_inputs(addr, ncoils)
-      query("\x2" + addr.to_bytes + ncoils.to_bytes).to_array_bit[0..ncoils-1]
+      query("\x2" + addr.to_word + ncoils.to_word).unpack_bits[0..ncoils-1]
     end
 
     # Deprecated version of read_discrete_inputs
@@ -154,14 +51,14 @@ module ModBus
     #
     # Return array of their values
     def read_holding_registers(addr, nreg) 
-      query("\x3" + addr.to_bytes + nreg.to_bytes).to_array_int16
+      query("\x3" + addr.to_word + nreg.to_word).unpack('n*')
     end
 
     # Read value *nreg* input registers starting with *addr*
     #
     # Return array of their values
     def read_input_registers(addr, nreg)
-      query("\x4" + addr.to_bytes + nreg.to_bytes).to_array_int16
+      query("\x4" + addr.to_word + nreg.to_word).unpack('n*')
     end
 
     # Write *val* in *addr* coil 
@@ -171,9 +68,9 @@ module ModBus
     # Return self
     def write_single_coil(addr, val)
       if val == 0
-        query("\x5" + addr.to_bytes + 0.to_bytes)
+        query("\x5" + addr.to_word + 0.to_word)
       else
-        query("\x5" + addr.to_bytes + 0xff00.to_bytes) 
+        query("\x5" + addr.to_word + 0xff00.to_word) 
       end
       self
     end
@@ -182,7 +79,7 @@ module ModBus
     #
     # Return self
     def write_single_register(addr, val)
-      query("\x6" + addr.to_bytes + val.to_bytes)
+      query("\x6" + addr.to_word + val.to_word)
       self
     end
 
@@ -205,7 +102,7 @@ module ModBus
         sum >>= 8 
       end
 
-      query("\xf" + addr.to_bytes + val.size.to_bytes + nbyte.chr + s_val)
+      query("\xf" + addr.to_word + val.size.to_word + nbyte.chr + s_val)
       self
     end
 
@@ -217,10 +114,10 @@ module ModBus
     def write_multiple_registers(addr, val)
       s_val = ""
       val.each do |reg|
-        s_val << reg.to_bytes
+        s_val << reg.to_word
       end
 
-      query("\x10" + addr.to_bytes + val.size.to_bytes + (val.size * 2).chr + s_val)
+      query("\x10" + addr.to_word + val.size.to_word + (val.size * 2).chr + s_val)
       self
     end
 
@@ -228,7 +125,7 @@ module ModBus
     #
     # Return self
     def mask_write_register(addr, and_mask, or_mask)
-      query("\x16" + addr.to_bytes + and_mask.to_bytes + or_mask.to_bytes)
+      query("\x16" + addr.to_word + and_mask.to_word + or_mask.to_word)
       self  
     end
 
@@ -239,11 +136,13 @@ module ModBus
       begin
         timeout(1, ModBusTimeout) do
         pdu = read_pdu
-       end
+      end
       rescue ModBusTimeout => err
         tried += 1
-        retry unless tried >= READ_RETRIES
-        raise ModBusTimeout.new, 'Timed out during read attempt'
+        retry unless tried >= @read_retries
+        raise ModBusTimeout.new, "Timed out during read attempt"
+      rescue 
+        raise ModBusException.new, "Server did not respond"
       end
     
       if pdu[0].to_i >= 0x80

data/lib/rmodbus/ext.rb

@@ -0,0 +1,61 @@
+# RModBus - free implementation of ModBus protocol on Ruby.
+#
+# Copyright (C) 2009  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.
+
+class String
+
+  unless RUBY_VERSION.to_f == 1.9
+    def getbyte(index)
+      self[index].to_i
+    end
+  end
+
+  def unpack_bits
+    array_bit = []
+    self.unpack('b*')[0].each_char do |b|
+        array_bit << b.to_i
+    end
+    array_bit
+  end
+
+end
+
+class Integer
+
+  def to_word
+    (self >> 8).chr + (self & 0xff).chr 
+  end
+
+end
+
+class Array
+
+  def pack_to_word
+    word = 0
+    s = ""
+    mask = 0x01
+
+    self.each do |bit| 
+      word |= mask if bit > 0
+      mask <<= 1
+      if mask  == 0x100
+        mask = 0x01
+        s << word.chr
+        word = 0
+      end
+    end
+    s << word.chr unless mask == 0x01
+  end
+
+end
+

data/lib/rmodbus/rtu_client.rb

@@ -0,0 +1,86 @@
+begin
+  require 'rubygems'
+rescue
+end
+require 'serialport'
+
+module ModBus
+  
+  class RTUClient < Client
+    
+    def initialize(port, rate=9600, slaveaddr=1)
+      @port = SerialPort.new(port, rate)
+      @slave = slaveaddr
+    end
+
+    protected
+    def send_pdu(pdu)
+      msg = @slave.chr + pdu 
+      msg << crc16(msg).to_word
+      @port.write msg
+    end
+
+    def read_pdu
+      msg =  @port.read
+      if msg.getbyte(0) == @slave
+        return msg[1..-3] if msg[-2,2] == crc16(msg[0..-3]).to_word
+      end
+      loop do
+        #waite timeout  
+      end
+    end
+
+    def crc16(msg)
+      crc_lo = 0xff
+      crc_hi = 0xff
+
+      msg.unpack('c*').each do |byte|
+        i = crc_hi ^ byte
+        crc_hi = crc_lo ^ CrcHiTable[i]
+        crc_lo = CrcLoTable[i]
+      end
+
+      return ((crc_hi << 8) + crc_lo)
+    end
+
+    CrcHiTable = [
+        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+        0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+        0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+        0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
+        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
+        0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+        0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+        0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+        0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+        0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+        0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+        0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+        0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+        0x40]
+    CrcLoTable = [
+        0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
+        0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
+        0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
+        0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
+        0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
+        0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
+        0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
+        0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
+        0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
+        0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
+        0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
+        0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
+        0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
+        0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
+        0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
+        0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
+        0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
+        0x40]
+  end
+
+end

data/lib/rmodbus/tcp_client.rb

@@ -35,7 +35,7 @@ module ModBus
       end
       rescue ModBusTimeout => err
         tried += 1
-        retry unless tried >= CONNECTION_RETRIES
+        retry unless tried >= @connection_retries 
         raise ModBusTimeout.new, 'Timed out attempting to create connection'
       end
       @slave = slaveaddr
@@ -51,16 +51,17 @@ module ModBus
 
     private
     def send_pdu(pdu)   
+      @@transaction = 0 if @@transaction.next > 65535
       @@transaction += 1 
-      @sock.write @@transaction.to_bytes + "\0\0" + (pdu.size + 1).to_bytes + @slave.chr + pdu
+      @sock.write @@transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @slave.chr + pdu
     end
 
     def read_pdu    
       header = @sock.read(7)            
       if header
-        tin = header[0,2].to_int16
+        tin = header[0,2].unpack('n')[0]
         raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @@transaction
-        len = header[4,2].to_int16       
+        len = header[4,2].unpack('n')[0]       
         @sock.read(len-1)               
       else
         raise Errors::ModBusException.new("Server did not respond")

data/lib/rmodbus/tcp_server.rb

@@ -17,12 +17,10 @@ require 'gserver'
 
 module ModBus
 	
-	class TCPServer < GServer
+  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)
@@ -37,27 +35,16 @@ module ModBus
     def serve(io)
       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
-        else
-          if req[2,2] != "\x00\x00" or req[6].to_i != @uid
-            io.close
-            break
-          end
+        if req[2,2] != "\x00\x00" or req.getbyte(6) != @uid
+          io.close
+          break
         end
  
         tr = req[0,2]
-        len = req[4,2].to_int16
+        len = req[4,2].unpack('n')[0]
         req = io.read(len - 1)
 
-        if RUBY_VERSION.to_f == 1.9
-          func = req.getbyte(0)
-        else
-          func = req[0].to_i
-        end
+        func = req.getbyte(0)
 
         unless Funcs.include?(func)
           param = { :err => 1 }
@@ -67,24 +54,24 @@ module ModBus
           when 1
             param = parse_read_func(req, @coils)
             if param[:err] == 0
-              val = @coils[param[:addr],param[:quant]].bits_to_bytes
+              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]].bits_to_bytes
+              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]].to_ints16
+              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]].to_ints16
+              res = func.chr + (param[:quant] * 2).chr + @input_registers[param[:addr],param[:quant]].pack('n*')
             end
           when 5 
             param = parse_write_coil_func(req)
@@ -112,7 +99,7 @@ module ModBus
             end
         end
         if param[:err] ==  0
-          resp = tr + "\0\0" + (res.size + 1).to_bytes + @uid.chr + res
+          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 
@@ -123,21 +110,21 @@ module ModBus
     private
 
     def parse_read_func(req, field)
-      quant = req[3,2].to_int16
+      quant = req[3,2].unpack('n')[0]
 
       return { :err => 3} unless quant <= 0x7d
         
-      addr = req[1,2].to_int16
+      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].to_int16
+      addr = req[1,2].unpack('n')[0]
       return { :err => 2 } unless addr <= @coils.size
 
-      val = req[3,2].to_int16
+      val = req[3,2].unpack('n')[0]
       return { :err => 3 } unless val == 0 or val == 0xff00
       
       val = 1 if val == 0xff00
@@ -145,10 +132,10 @@ module ModBus
     end
 
     def parse_write_register_func(req)
-      addr = req[1,2].to_int16
+      addr = req[1,2].unpack('n')[0]
       return { :err => 2 } unless addr <= @coils.size
 
-      val = req[3,2].to_int16
+      val = req[3,2].unpack('n')[0]
 
       return { :err => 0, :addr => addr, :val => val }  
 	  end
@@ -157,7 +144,7 @@ module ModBus
       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 }
+        param = {:err => 0, :addr => param[:addr], :quant => param[:quant], :val => req[6,param[:quant]].unpack_bits }
       end
       param
     end
@@ -166,7 +153,7 @@ module ModBus
       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].to_array_int16 }
+        param = {:err => 0, :addr => param[:addr], :quant => param[:quant], :val => req[6,param[:quant] * 2].unpack('n*')}
       end
       param
     end

data/lib/rmodbus.rb

@@ -11,3 +11,5 @@
 # GNU General Public License for more details.
 require 'rmodbus/tcp_client'
 require 'rmodbus/tcp_server'
+require 'rmodbus/rtu_client'
+

data/spec/ext_spec.rb

@@ -2,33 +2,13 @@ require 'rmodbus'
 
 describe Array do
 
-  it "should return string reprisent 16bit" do
-    arr = [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
-    arr.bits_to_bytes.should == "\xcd\x6b\x5" 
-  end
-
-  it "should return string reprisent 16bit fot 8 bits" do
-    arr = [1,0,1,1, 0,0,1,1]
-    arr.bits_to_bytes.should == "\xcd"
+  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 16ints" do
-    arr = [1,2] 
-    arr.to_ints16 == "\x0\x1\x0\x2"
+  it "should return string reprisent 16bit" do
+    @arr.pack_to_word == "\xcd\x6b\x5" 
   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
-  
-  it "should have convert 2 chars to word" do
-    str = "\x1\x1"
-    str.to_int16.should == 257
-  end
-
-end

data/spec/rtu_client_spec.rb

@@ -0,0 +1,40 @@
+begin
+  require 'rubygems'
+rescue
+end
+require 'rmodbus'
+
+include ModBus
+
+describe RTUClient do
+    
+  before do 
+    @port = mock('Serial port')
+    SerialPort.should_receive(:new).with("/dev/port1", 9600).and_return(@port)    
+    @mb_client = RTUClient.new("/dev/port1", 9600, 1)
+    @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")
+    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")
+    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")
+    @mb_client.query(request).should == "\xff\xff"
+  end
+
+end
+

data/spec/tcp_client_spec.rb

@@ -6,7 +6,7 @@ describe TCPClient, "method 'query'"  do
 
   UID = 1
 
-  before do
+  before(:each) do
     @sock = mock("Socket")
     @adu = "\000\001\000\000\000\001\001"
 
@@ -17,14 +17,14 @@ describe TCPClient, "method 'query'"  do
   end
 
   it 'should send valid MBAP Header' do
-    @adu[0,2] = TCPClient.transaction.next.to_bytes
+    @adu[0,2] = TCPClient.transaction.next.to_word
     @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
+    @adu[0,2] = TCPClient.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)
     begin
@@ -37,7 +37,7 @@ describe TCPClient, "method 'query'"  do
   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
+    @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)

data/spec/tcp_server_spec.rb

@@ -10,6 +10,7 @@ describe TCPServer do
     @server.input_registers = [1,2,3,4]
     @server.start
     @client = ModBus::TCPClient.new('127.0.0.1', 8502, 1)
+    @client.read_retries = 0
   end
 
   it "should silent if UID has mismatched" do
@@ -20,15 +21,18 @@ describe TCPServer do
     rescue ModBus::Errors::ModBusException => ex
       ex.message.should == "Server did not respond"
     end
+    client.close
   end
 
   it "should silent if protocol identifer has mismatched" do
+    @client.close
     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
+    client.close
   end
 
   it "should send exception if function not supported" do
@@ -55,6 +59,12 @@ describe TCPServer do
     end
   end
 
+  it "should calc a many requests" do
+    @client.read_coils(1,2)
+    @client.write_multiple_registers(0,[9,9,9,])
+    @client.read_holding_registers(0,3).should == [9,9,9]
+  end
+
   it "should supported function 'read coils'" do
     @client.read_coils(0,3).should == @server.coils[0,3]
   end
@@ -95,15 +105,10 @@ describe TCPServer do
     @server.holding_registers.should == [1,2,3,1,2,3,4,5,9]
   end
 
-  it "should valid respond on query reading more than 8 coils at once bug#26387" do
-    @server.coils = [0,0,1,1,0,0,1,1,0,0]
-    @client.read_coils(0,7)
-    @client.read_coils(1,9)
-    @client.read_coils(0,8)
-  end
-
   after do
-    @client.close if @client
-    @server.stop if @server
+    @client.close 
+    @server.stop unless @server.stopped?
+    while GServer.in_service?(8502) 
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rmodbus
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors: 
 - A.Timin, J. Sanders
@@ -9,7 +9,7 @@ autorequire: rmodbus
 bindir: bin
 cert_chain: []
 
-date: 2009-06-22 00:00:00 +05:00
+date: 2010-01-07 00:00:00 +05:00
 default_executable: 
 dependencies: []
 
@@ -23,23 +23,26 @@ extra_rdoc_files:
 - README
 - AUTHORS
 - LICENSE
-- CHANGES
+- ChangeLog
 files: 
-- lib/rmodbus.rb
-- lib/rmodbus/exceptions.rb
 - lib/rmodbus/tcp_client.rb
-- lib/rmodbus/client.rb
+- lib/rmodbus/rtu_client.rb
 - lib/rmodbus/tcp_server.rb
-- examples/add_new_function.rb
+- lib/rmodbus/exceptions.rb
+- lib/rmodbus/client.rb
+- lib/rmodbus/ext.rb
+- lib/rmodbus.rb
 - examples/use_tcp_modbus.rb
+- examples/add_new_function.rb
 - spec/ext_spec.rb
-- spec/client_spec.rb
 - spec/tcp_client_spec.rb
+- spec/rtu_client_spec.rb
+- spec/client_spec.rb
 - spec/tcp_server_spec.rb
 - README
 - AUTHORS
 - LICENSE
-- CHANGES
+- ChangeLog
 has_rdoc: true
 homepage: 
 licenses: []
@@ -68,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: RModBus - free implementation of protocol ModBus

data/CHANGES

@@ -1,17 +0,0 @@
-2008-25-01 Release-0.1.1
-- fixed bug in function "read discrete inputs (0x2)" of ModBus client
-
-2009-30-01 Release-0.2
-- add ModBus-TCP server
-- add retries for tcp connection and read, default of 10 retries, still 1 second timeout
-- fix typos
-
-2009-09-02 Release-0.2.1
-- add support ruby 1.9.1
-- fix bug in TCPServer class (it don't close connection after first request now)
-
-2009-17-04 Release-0.2.2
-- Make exceptions inherit from StandardError instead of Exception
-
-2009-22-06 Release-0.2.3
-- fix bug #26387