rmodbus 0.1.1 → 0.2

data/lib/rmodbus.rb

@@ -10,3 +10,4 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 require 'rmodbus/tcp_client'
+require 'rmodbus/tcp_server'

data/lib/rmodbus/client.rb

@@ -54,11 +54,43 @@ class Integer
   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
+  end
+
+end
+
 module ModBus
 
   class Client
   
     include Errors
+    # Number of times to retry on connection and read timeouts
+    CONNECTION_RETRIES = 10
+    READ_RETRIES = 10
 
     # Read value *ncoils* coils starting with *addr*
     #
@@ -70,10 +102,16 @@ module ModBus
     # Read value *ncoils* discrete inputs starting with *addr*
     #
     # Return array of their values
-    def read_discret_inputs(addr, ncoils)
+    def read_discrete_inputs(addr, ncoils)
       query("\x2" + addr.to_bytes + ncoils.to_bytes).to_array_bit[0..ncoils-1]
     end
 
+    # Deprecated version of read_discrete_inputs
+    def read_discret_inputs(addr, ncoils)
+      warn "[DEPRECATION] `read_discret_inputs` is deprecated.  Please use `read_discrete_inputs` instead."
+      read_discrete_inputs(addr, ncoils)
+    end
+
     # Read value *nreg* holding registers starting with *addr*
     #
     # Return array of their values
@@ -159,8 +197,15 @@ module ModBus
     def query(pdu)    
       send_pdu(pdu)
 
-      timeout(1) do
-        pdu = read_pdu
+      tried = 0
+      begin
+        timeout(1, ModBusTimeout) do
+        pdu = read_pdu
+       end
+      rescue ModBusTimeout => err
+        tried += 1
+        retry unless tried >= READ_RETRIES
+        raise ModBusTimeout.new, 'Timed out during read attempt'
       end
     
       if pdu[0].to_i >= 0x80
@@ -176,23 +221,26 @@ module ModBus
           when 5
             raise Acknowledge.new, "The server has accepted the request and is processing it, but a long duration of time will be required to do so"
           when 6
-            raise SlaveDiviceBus.new, "The server is engaged in processing a long duration program command"
+            raise SlaveDeviceBus.new, "The server is engaged in processing a long duration program command"
           when 8
             raise MemoryParityError.new, "The extended file area failed to pass a consistency check"
           else
-            raise ModBusException.new, "Unknow error"
+            raise ModBusException.new, "Unknown error"
         end
       end
       pdu[2..-1]
     end
 
-     protected
+    protected
     def send_pdu(pdu)
     end
 
     def read_pdu
     end
 
+    def close
+    end
+
   end
 
 end

data/lib/rmodbus/exceptions.rb

@@ -33,12 +33,15 @@ module ModBus
     class Acknowledge < ModBusException
     end
 
-    class SlaveDiviceBus < ModBusException
+    class SlaveDeviceBus < ModBusException
     end
 
     class MemoryParityError < ModBusException
     end
 
+    class ModBusTimeout < ModBusException
+    end
+
   end
 
 end

data/lib/rmodbus/rtu_client.rb

@@ -0,0 +1,6 @@
+module ModBus
+  
+  class RTUClient
+  end
+
+end

data/lib/rmodbus/tcp_client.rb

@@ -15,7 +15,6 @@ require 'socket'
 require 'timeout'
 require 'rmodbus/client'
 require 'rmodbus/exceptions'
-require 'rmodbus/adu'
 
 module ModBus
 
@@ -24,26 +23,49 @@ module ModBus
 
     include Timeout
 
+    @@transaction = 0
+
     # Connect with a ModBus server
     def initialize(ipaddr, port = 502, slaveaddr = 1)
-      timeout(1) do
+      
+      tried = 0
+      begin
+        timeout(1, ModBusTimeout) do
         @sock = TCPSocket.new(ipaddr, port)
       end
+      rescue ModBusTimeout => err
+        tried += 1
+        retry unless tried >= CONNECTION_RETRIES
+        raise ModBusTimeout.new, 'Timed out attempting to create connection'
+      end
       @slave = slaveaddr
     end
+
+    def close
+      @sock.close unless @sock.closed?
+    end
  
+
+    def self.transaction 
+      @@transaction
+    end
+
     private
     def send_pdu(pdu)   
-      @adu = ADU.new(pdu,@slave) 
-      @sock.write @adu.serialize
+      @@transaction += 1 
+      @sock.write @@transaction.to_bytes + "\0\0" + (pdu.size + 1).to_bytes + @slave.chr + pdu
     end
 
     def read_pdu     
       header = @sock.read(7)            
-      tin = header[0,2].to_int16
-      raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @adu.transaction_id
-      len = header[4,2].to_int16       
-      @sock.read(len-1)               
+      if header
+        tin = header[0,2].to_int16
+        raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @@transaction
+        len = header[4,2].to_int16       
+        @sock.read(len-1)               
+      else
+        raise Errors::ModBusException.new("Server did not respond")
+      end
     end
 
   end

data/lib/rmodbus/tcp_server.rb

@@ -0,0 +1,158 @@
+# 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
+        param = {:err => 0, :addr => param[:addr], :quant => param[:quant], :val => req[6,param[:quant] * 2].to_array_int16 }
+      end
+      param
+    end
+
+	end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: rmodbus
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: "0.2"
 platform: ruby
 authors: 
-- A.Timin, D.Samatov
+- A.Timin, J. Sanders
 autorequire: rmodbus
 bindir: bin
 cert_chain: []
 
-date: 2008-01-25 00:00:00 +05:00
+date: 2009-01-30 00:00:00 +05:00
 default_executable: 
 dependencies: []
 
@@ -25,11 +25,14 @@ 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/adu.rb
-- lib/rmodbus/client.rb
 - lib/rmodbus.rb
+- ext/extconf.rb
+- ext/serialport.c
 - README
 - AUTHORS
 - LICENSE
@@ -60,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.0.1
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: RModBus - free implementation of protocol ModBus

data/lib/rmodbus/adu.rb

@@ -1,36 +0,0 @@
-# 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.
-module ModBus
-  
-    class ADU
-      
-      @@transaction_id = 0
-
-      attr_reader :unit_id, :transaction_id, :pdu, :size
-
-      def initialize(pdu, uid)
-        @pdu = pdu
-        @size = pdu.size + 1
-        @unit_id = uid
-        @transaction_id = @@transaction_id
-        @@transaction_id += 1
-      end
-
-      def serialize
-        @transaction_id.to_bytes + "\x00\x00" + @size.to_bytes + @unit_id.chr + pdu
-      end
-
-    end
-
-end