rmodbus 0.3.1 → 0.4.0

data/lib/rmodbus/parsers.rb

@@ -0,0 +1,133 @@
+# RModBus - free implementation of ModBus protocol in purge Ruby.
+#
+# Copyright (C) 2010  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
+  module Parsers
+
+    Funcs = [1,2,3,4,5,6,15,16]
+
+    def exec_req(req, coils, discrete_inputs, holding_registers, input_registers)
+      func = req.getbyte(0)
+        
+      unless Funcs.include?(func)
+        params = { :err => 1 }
+      end
+        
+      case func
+        when 1
+          params = parse_read_func(req, coils)
+          if params[:err] == 0
+            val = coils[params[:addr],params[:quant]].pack_to_word
+            pdu = func.chr + val.size.chr + val
+          end
+        when 2
+          params = parse_read_func(req, discrete_inputs)
+          if params[:err] == 0
+            val = discrete_inputs[params[:addr],params[:quant]].pack_to_word
+            pdu = func.chr + val.size.chr + val
+          end
+        when 3
+          params = parse_read_func(req, holding_registers)
+          if params[:err] == 0
+            pdu = func.chr + (params[:quant] * 2).chr + holding_registers[params[:addr],params[:quant]].pack('n*')
+          end
+        when 4
+          params = parse_read_func(req, input_registers)
+          if params[:err] == 0
+            pdu = func.chr + (params[:quant] * 2).chr + input_registers[params[:addr],params[:quant]].pack('n*')
+          end
+        when 5 
+          params = parse_write_coil_func(req)
+          if params[:err] == 0
+            coils[params[:addr]] = params[:val]
+            pdu = req
+          end
+        when 6
+          params = parse_write_register_func(req)
+          if params[:err] == 0
+            holding_registers[params[:addr]] = params[:val]
+            pdu = req
+          end
+        when 15
+          params = parse_write_multiple_coils_func(req)
+          if params[:err] == 0
+            coils[params[:addr],params[:quant]] = params[:val][0,params[:quant]]
+            pdu = req[0,5]
+          end
+        when 16
+          params = parse_write_multiple_registers_func(req)
+          if params[:err] == 0
+            holding_registers[params[:addr],params[:quant]] = params[:val][0,params[:quant]]
+            pdu = req[0,5]
+          end
+      end
+      
+      if params[:err] == 0
+        pdu 
+      else
+        pdu = (func | 0x80).chr + params[:err].chr
+      end
+    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)
+      params = parse_read_func(req, @coils)
+
+      if params[:err] == 0
+        params = {:err => 0, :addr => params[:addr], :quant => params[:quant], :val => req[6,params[:quant]].unpack_bits }
+      end
+      params
+    end
+
+    def parse_write_multiple_registers_func(req)
+      params = parse_read_func(req, @holding_registers)
+
+      if params[:err] == 0
+        params = {:err => 0, :addr => params[:addr], :quant => params[:quant], :val => req[6,params[:quant] * 2].unpack('n*')}
+      end
+      params
+    end
+  end
+end

data/lib/rmodbus/rtu_client.rb

@@ -1,3 +1,18 @@
+# RModBus - free implementation of ModBus protocol in 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.
+require 'rmodbus/crc16'
+
 begin
   require 'rubygems'
 rescue
@@ -7,86 +22,116 @@ require 'serialport'
 module ModBus
   
   class RTUClient < Client
-    
-    def initialize(port, rate=9600, slaveaddr=1)
-      @port = SerialPort.new(port, rate)
-      @port.read_timeout = 5
-      @slave = slaveaddr
+
+    include CRC16
+    attr_reader :port, :baud, :slave, :data_bits, :stop_bits, :parity
+    attr_accessor :debug
+
+    # Connect with RTU server
+    #
+    # port - serial port of connections with RTU server
+    #
+    # baud - rate sp of connections with RTU server
+    #
+    # slaveaddr - slave ID of the RTU server
+    #
+    # Options:
+    #
+    # :data_bits => from 5 to 8
+    #
+    # :stop_bits => 1 or 2
+    #
+    # :parity => NONE, EVEN or ODD
+    #
+    # RTUClient.connect('/dev/port1') do |cl|
+    #
+    #   put cl.read_holding_registers(0, 10)
+    #
+    # end
+    def self.connect(port, baud=9600, slaveaddr=1, options = {})
+      cl = RTUClient.new(port, baud, slaveaddr, options) 
+      yield cl
+      cl.close
+    end
+
+    # Connect with RTU server
+    #
+    # port - serial port of connections with RTU server
+    #
+    # baud - rate sp of connections with RTU server
+    #
+    # data_bits - from 5 to 8
+    #
+    # stop_bits - 1 or 2
+    #
+    # parity - NONE, EVEN or ODD
+    #
+    # slaveaddr - slave ID of the RTU server    # Connect with RTU server
+    #
+    # port - serial port of connections with RTU server
+    #
+    # baud - rate sp of connections with RTU server
+    #
+    # slaveaddr - slave ID of the RTU server
+    #
+    # Options:
+    #
+    # :data_bits => from 5 to 8
+    #
+    # :stop_bits => 1 or 2
+    #
+    # :parity => NONE, EVEN or ODD
+    def initialize(port, baud=9600, slaveaddr=1, options = {})
+      @port, @baud, @slave = port, baud, slaveaddr
+      
+      @data_bits, @stop_bits, @parity = 8, 1, SerialPort::NONE
+
+      @data_bits = options[:data_bits] unless options[:data_bits].nil?
+      @stop_bits = options[:stop_bits] unless options[:stop_bits].nil?
+      @parity = options[:parity] unless options[:parity].nil?
+
+      @debug = false
+
+      @sp = SerialPort.new(@port, @baud, @data_bits, @stop_bits, @parity)
+      @sp.read_timeout = 5
+
       super()
     end
 
+    def close
+      @sp.close unless @sp.closed?
+    end
+
+    def closed?
+      @sp.closed?
+    end
+
     protected
     def send_pdu(pdu)
       msg = @slave.chr + pdu 
       msg << crc16(msg).to_word
-      @port.write msg
+      @sp.write msg
+      if @debug
+        STDOUT << "Tx (#{msg.size} bytes): " + logging_bytes(msg) + "\n"
+      end
     end
 
     def read_pdu
       msg = ''
-      while msg.size == 0 do
-        msg =  @port.read
+      while msg.size == 0
+        msg =  @sp.read
+      end
+
+      if @debug
+        STDOUT << "Rx (#{msg.size} bytes): " + logging_bytes(msg) + "\n"
       end
 
       if msg.getbyte(0) == @slave
-        return msg[1..-3] if msg[-2,2] == crc16(msg[0..-3]).to_word
+        return msg[1..-3] if msg[-2,2].unpack('n')[0] == crc16(msg[0..-3])
       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/rtu_server.rb

@@ -0,0 +1,90 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2010  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/parsers'
+
+begin
+  require 'rubygems'
+rescue
+end
+
+require 'serialport'
+
+module ModBus
+ 
+  class RTUServer
+    include Parsers
+    include CRC16
+
+    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers
+    attr_reader :port, :baud, :slave, :data_bits, :stop_bits, :parity
+
+     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, baud=9600, slaveaddr=1, options = {})
+      Thread.abort_on_exception = true 
+
+      @port, @baud = port, baud
+      @data_bits, @stop_bits, @parity = 8, 1, SerialPort::NONE
+
+      @data_bits = options[:data_bits] unless options[:data_bits].nil?
+      @stop_bits = options[:stop_bits] unless options[:stop_bits].nil?
+      @parity = options[:parity] unless options[:parity].nil?
+
+      @sp = SerialPort.new(@port, @baud, @data_bits, @stop_bits, @parity)
+      @sp.read_timeout = 5
+
+      @coils = []
+      @discrete_inputs = []
+      @holding_registers = []
+      @input_registers = []
+      @slave = slaveaddr
+    end
+
+    def start
+      @serv = Thread.new do
+        loop do
+          req = '' 
+          while req.size == 0 
+            req = @sp.read
+          end
+          if req.getbyte(0) == @slave and req[-2,2].unpack('n')[0] == crc16(req[0..-3])
+            pdu = exec_req(req[1..-1], @coils, @discrete_inputs, @holding_registers, @input_registers)
+            resp = @slave.chr + pdu
+            resp << crc16(resp).to_word
+            @sp.write resp
+          end
+        end
+      end
+    end
+
+    def stop
+      Thread.kill(@serv)
+      @sp.close 
+    end
+
+    def join
+      @serv.join
+    end
+  end
+end

data/lib/rmodbus/tcp_client.rb

@@ -23,12 +23,39 @@ module ModBus
 
     include Timeout
 
+    attr_reader :ipaddr, :port, :slave
+    attr_accessor :debug
+
     @@transaction = 0
+    
+    # Connect with ModBus server
+    #
+    # ipaddr - ip of the server
+    #
+    # port - port TCP connections
+    #
+    # slaveaddr - slave ID of the server
+    #
+    # TCPClient.connect('127.0.0.1') do |cl|
+    #
+    #   put cl.read_holding_registers(0, 10)
+    #
+    # end
+    def self.connect(ipaddr, port = 502, slaveaddr = 1)
+      cl = TCPClient.new(ipaddr, port, slaveaddr) 
+      yield cl
+      cl.close
+    end
 
     # Connect with a ModBus server
+    #
+    # ipaddr - ip of the server
+    #
+    # port - port TCP connections
+    #
+    # slaveaddr - slave ID of the server
     def initialize(ipaddr, port = 502, slaveaddr = 1)
       @ipaddr, @port = ipaddr, port
-      super()
       tried = 0
       begin
         timeout(1, ModBusTimeout) do
@@ -40,12 +67,20 @@ module ModBus
         raise ModBusTimeout.new, 'Timed out attempting to create connection'
       end
       @slave = slaveaddr
+      @debug = false
+      super()
     end
 
+    # Close TCP connections
     def close
       @sock.close unless @sock.closed?
     end
 
+    # Check TCP connections
+    def closed?
+      @sock.closed?
+    end
+
     def self.transaction 
       @@transaction
     end
@@ -54,7 +89,12 @@ module ModBus
     def send_pdu(pdu)   
       @@transaction = 0 if @@transaction.next > 65535
       @@transaction += 1 
-      @sock.write @@transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @slave.chr + pdu
+      msg = @@transaction.to_word + "\0\0" + (pdu.size + 1).to_word + @slave.chr + pdu
+      @sock.write msg
+      
+      if debug
+        STDOUT << "Tx (#{msg.size} bytes): " + logging_bytes(msg) + "\n"
+      end
     end
 
     def read_pdu    
@@ -63,7 +103,11 @@ module ModBus
         tin = header[0,2].unpack('n')[0]
         raise Errors::ModBusException.new("Transaction number mismatch") unless tin == @@transaction
         len = header[4,2].unpack('n')[0]       
-        @sock.read(len-1)               
+        msg = @sock.read(len-1)               
+        if @debug
+          STDOUT << "Rx (#{(header + msg).size} bytes): " + logging_bytes(header + msg) + "\n"
+        end
+        msg
       else
         raise Errors::ModBusException.new("Server did not respond")
       end