rmodbus 1.0.0-java

data/lib/rmodbus/rtu.rb

@@ -0,0 +1,140 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2010 - 2011  Timin Aleksey
+# Copyright (C) 2010  Kelley Reynolds
+#
+# 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 RTU
+    private
+
+    # We have to read specific amounts of numbers of bytes from the network depending on the function code and content
+    def read_rtu_response(io)
+	    # Read the slave_id and function code
+	    msg = io.read(2)
+      function_code = msg.getbyte(1)
+      case function_code
+        when 1,2,3,4 then
+          # read the third byte to find out how much more
+          # we need to read + CRC
+          msg += io.read(1)
+          msg += io.read(msg.getbyte(2)+2)
+        when 5,6,15,16 then
+          # We just read in an additional 6 bytes
+          msg += io.read(6)
+        when 22 then
+          msg += io.read(8)
+        when 0x80..0xff then
+          msg += io.read(4)
+        else
+          raise ModBus::Errors::IllegalFunction, "Illegal function: #{function_code}"
+      end
+    end
+
+    def read_rtu_request(io)
+			# Read the slave_id and function code
+			msg = io.read(2)
+
+			# If msg is nil, then our client never sent us anything and it's time to disconnect
+			return if msg.nil?
+
+			function_code = msg.getbyte(1)
+			if [1, 2, 3, 4, 5, 6].include?(function_code)
+				# read 6 more bytes and return the message total message
+				msg += io.read(6)
+			elsif [15, 16].include?(function_code)
+				# Read in first register, register count, and data bytes
+				msg += io.read(5)
+				# Read in however much data we need to + 2 CRC bytes
+				msg += io.read(msg.getbyte(6) + 2)
+			else
+				raise ModBus::Errors::IllegalFunction, "Illegal function: #{function_code}"
+			end
+
+			log "Server RX (#{msg.size} bytes): #{logging_bytes(msg)}"
+
+			msg
+		end
+
+    def serv_rtu_requests(io, &blk)
+      loop do
+        # read the RTU message
+        msg = read_rtu_request(io)
+        # If there is no RTU message, we're done serving this client
+        break if msg.nil?
+
+        if msg.getbyte(0) == @uid and msg[-2,2].unpack('n')[0] == crc16(msg[0..-3])
+          pdu = yield msg
+          resp = @uid.chr + pdu
+          resp << crc16(resp).to_word
+          log "Server TX (#{resp.size} bytes): #{logging_bytes(resp)}"
+          io.write resp
+		    end
+	    end
+    end
+
+    # Calc CRC16 for massage
+    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_client.rb

@@ -0,0 +1,41 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2009-2011  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
+  # RTU client implementation
+  # @example
+  #   RTUClient.connect('/dev/ttyS1', 9600) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUClient#open_connection
+  # @see Client#initialize
+  class RTUClient < Client
+    include RTU
+    include SP
+
+    protected
+    # Open serial port
+    # @see SP#open_serial_port
+    def open_connection(port, baud=9600, opts = {})
+      open_serial_port(port, baud, opts)
+    end
+
+    # @private
+    def get_slave(uid, io)
+      RTUSlave.new(uid, io)
+    end
+  end
+end

data/lib/rmodbus/rtu_server.rb

@@ -0,0 +1,61 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2010-2011 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 'serialport'
+
+module ModBus
+  # RTU server implementation
+  # @example
+  #   srv = RTUServer.new('/dev/ttyS1', 9600, 1)
+  #   srv.coils = [1,0,1,1]
+  #   srv.discrete_inputs = [1,1,0,0]
+  #   srv.holding_registers = [1,2,3,4]
+  #   srv.input_registers = [1,2,3,4]
+  #   srv.debug = true
+  #   srv.start
+  class RTUServer
+    include Common
+    include Server
+    include RTU
+    include SP
+
+    # Init RTU server
+    # @param [Integer] uid slave device
+    # @see SP#open_serial_port
+    def initialize(port, baud=9600, uid=1, opts = {})
+      Thread.abort_on_exception = true
+      @sp = open_serial_port(port, baud, opts)
+      @uid = uid
+    end
+
+    # Start server
+    def start
+      @serv = Thread.new do
+        serv_rtu_requests(@sp) do |msg|
+          exec_req(msg[1..-3], @coils, @discrete_inputs, @holding_registers, @input_registers)
+        end
+      end
+    end
+
+    # Stop server
+    def stop
+      Thread.kill(@serv)
+      @sp.close
+    end
+
+    # Join server
+    def join
+      @serv.join
+    end
+  end
+end

data/lib/rmodbus/rtu_slave.rb

@@ -0,0 +1,59 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2011  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
+  # RTU slave implementation
+  # @example
+  #   RTUClient.connect(port, baud, opts) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUClient#open_connection
+  # @see Client#with_slave
+  # @see Slave
+  class RTUSlave < Slave
+    include RTU
+
+    protected
+
+    # overide method for RTU implamentaion
+    # @see Slave#query
+    def send_pdu(pdu)
+      msg = @uid.chr + pdu
+      msg << crc16(msg).to_word
+      @io.write msg
+
+      log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+    end
+
+    # overide method for RTU implamentaion
+    # @see Slave#query
+    def read_pdu
+	    msg = read_rtu_response(@io)
+
+      log "Rx (#{msg.size} bytes): " + logging_bytes(msg)
+
+      if msg.getbyte(0) == @uid
+        return msg[1..-3] if msg[-2,2].unpack('n')[0] == crc16(msg[0..-3])
+        log "Ignore package: don't match CRC"
+      else
+        log "Ignore package: don't match uid ID"
+      end
+      loop do
+        #waite timeout
+      end
+    end
+  end
+end

data/lib/rmodbus/rtu_via_tcp_client.rb

@@ -0,0 +1,41 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2009-2011  Timin Aleksey
+# Copyright (C) 2010  Kelley Reynolds
+#
+# 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
+  # RTU over TCP client implementation
+  # @example
+  #   RTUViaTCPClient.connect('127.0.0.1', 10002) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUViaTCPClient#open_connection
+  # @see Client#initialize
+  class RTUViaTCPClient < Client
+		include RTU
+		include TCP
+
+    protected
+		# Open TCP\IP connection
+    # @see TCP#open_tcp_connection
+    def open_connection(ipaddr, port = 10002, opts = {})
+      io = open_tcp_connection(ipaddr, port, opts)
+		end
+
+    def get_slave(uid, io)
+      RTUViaTCPSlave.new(uid, io)
+    end
+	end
+end

data/lib/rmodbus/rtu_via_tcp_server.rb

@@ -0,0 +1,50 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2010  Timin Aleksey
+# Copyright (C) 2010  Kelley Reynolds
+#
+# 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 'gserver'
+
+module ModBus
+  # RTU over TCP server implementation
+  # @example
+  #   srv = RTUViaTCPServer.new(10002, 1)
+  #   srv.coils = [1,0,1,1]
+  #   srv.discrete_inputs = [1,1,0,0]
+  #   srv.holding_registers = [1,2,3,4]
+  #   srv.input_registers = [1,2,3,4]
+  #   srv.debug = true
+  #   srv.start
+  class RTUViaTCPServer < GServer
+    include Common
+    include RTU
+    include Server
+
+    # Init server
+    # @param [Integer] port listen port
+    # @param [Integer] uid slave device
+    def initialize(port = 10002, uid = 1)
+      @uid = uid
+      super(port)
+    end
+
+    protected
+    # Serve requests
+    # @param [TCPSocket] io socket
+    def serve(io)
+      serv_rtu_requests(io) do |msg|
+        exec_req(msg[1..-3], @coils, @discrete_inputs, @holding_registers, @input_registers)
+      end
+    end
+  end
+end

data/lib/rmodbus/rtu_via_tcp_slave.rb

@@ -0,0 +1,58 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2011  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
+  # RTU over TCP slave implementation
+  # @example
+  #   RTUViaTCP.connect('127.0.0.1', 10002) do |cl|
+  #     cl.with_slave(uid) do |slave|
+  #       slave.holding_registers[0..100]
+  #     end
+  #   end
+  #
+  # @see RTUViaTCPClient#open_connection
+  # @see Client#with_slave
+  # @see Slave
+  class RTUViaTCPSlave < Slave
+		include RTU
+
+		protected
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+		def send_pdu(pdu)
+			msg = @uid.chr + pdu
+			msg << crc16(msg).to_word
+			@io.write msg
+
+			log "Tx (#{msg.size} bytes): " + logging_bytes(msg)
+		end
+
+    # overide method for RTU over TCP implamentaion
+    # @see Slave#query
+		def read_pdu
+			# Read the response appropriately
+			msg = read_rtu_response(@io)
+
+			log "Rx (#{msg.size} bytes): " + logging_bytes(msg)
+			if msg.getbyte(0) == @uid
+				return msg[1..-3] if msg[-2,2].unpack('n')[0] == crc16(msg[0..-3])
+				log "Ignore package: don't match CRC"
+			else
+				log "Ignore package: don't match uid ID"
+			end
+			loop do
+				#waite timeout
+			end
+		end
+	end
+end

data/lib/rmodbus/server.rb

@@ -0,0 +1,142 @@
+# RModBus - free implementation of ModBus protocol in Ruby.
+#
+# Copyright (C) 2010  Timin Aleksey
+# Copyright (C) 2010  Kelley Reynolds
+#
+# 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 for implementation ModBus server
+  module Server
+    Funcs = [1,2,3,4,5,6,15,16]
+
+    attr_accessor :coils, :discrete_inputs, :holding_registers, :input_registers, :uid
+    @coils = []
+    @discrete_inputs = []
+    @holding_registers =[]
+    @input_registers = []
+
+    private
+
+    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
+
+    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