rmodbus 1.3.3 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f5d1df9b7aee29daa2fa8d77ceeae3cd556c02b8
-  data.tar.gz: 12c6489b6afb7741852cba230376e1b4a63b955f
+SHA256:
+  metadata.gz: 025a947981907584989c025378c6ea0650afc8d102a05431fc084d1e9da84e4b
+  data.tar.gz: d7f722ccf020d283e0cc83ece81f640ce85b1c323391b7ab67e8cfa970504536
 SHA512:
-  metadata.gz: a326a79e98ffa8cc2158111a68e1a9e2fc41061e6548f8765d9ef1ee52ce0007959d6bdd2e31341ef9d8c7c982b4100d18f1304325e2d470c992288e384adbf2
-  data.tar.gz: bf50d64b8a86e54549e7a3833dbbd41f5a59c472bcf1c73b291e321c5d0f471012f7d7ac3cb6978323fb1c69baed7cc87f83eb178efb4f6a176a63d1836f40c0
+  metadata.gz: bf1c1cad9756deec4519ffb2f0a157d579a34c1f6a5189508e337432566997a6bfac5f1cd44ef58da8bf1805aa9b6d8dbe7d1efb5a64aa2c32a228191bfc4607
+  data.tar.gz: a2390510c7a066d7a5df9430dbc7d23706da4e5f0a8f3c9f5ccf7e410e53bdd6d1f88dc94bf1a7f9e301fd0aea323817e6a52879793595c1b6b091670998ffc4

data/NEWS.md

@@ -1,3 +1,22 @@
+###2024-08-20 Release 2.1.1
+
+1. [BREAKING] Servers now support publishing multiple slaves
+2. [BREAKING] RTUViaTCPClient/RTUViaTCPSlave are gone. Please just use RTUClient directly
+3. [BREAKING] Proxy collections no longer return an array when requesting a single item.
+4. [BREAKING] to/from_32* use big endian order. if you want little endian order for the 
+   constituent 16-bit registers, use `wordswap` before/after conversion as appropriate.
+5. [BREAKING] to/from_32i works with _signed_ integers. If you want unsigned, use 32u
+6. Don't time out waiting to read a response that will never come from broadcast commands
+7. Don't send responses to broadcast commands as a server
+8. Properly function as a server in an environment with multiple RTU slaves
+9. Server now supports promiscuous mode to dump the conversation happening between a master and other slaves.
+10. Add read/write multiple registers function (server and client)
+11. Add mask write register function to server
+12. Log to a logger object, not $stderr
+13. Improve RTU read resiliency with partial reads
+14. Callbacks in server to implement additional custom processing
+15. Ability to use any IO (including a proxy you've set up) with RTUClient
+
 ###2017-03-30 Release 1.3.2
 
 1. Fix Fixnum warning on Ruby 2.4

data/README.md

@@ -1,16 +1,16 @@
-RModBus [![Build Status](https://secure.travis-ci.org/rmodbus/rmodbus.png)](http://travis-ci.org/rmodbus/rmodbus) [![Gem Version](https://badge.fury.io/rb/rmodbus.svg)](http://badge.fury.io/rb/rmodbus)
+RModBus [![Gem Version](https://badge.fury.io/rb/rmodbus.svg)](http://badge.fury.io/rb/rmodbus)
 ==========================
 
 **RModBus** - free implementation of ModBus protocol in pure Ruby.
 
 Features
 ---------------------------
-  - Ruby 2.2, 2.3 and JRuby (without serial ModBus RTU)
+  - Ruby 2.5+ and JRuby (without serial ModBus RTU)
   - TCP, RTU, RTU over TCP protocols
   - Client(master) and server(slave)
-  - 16, 32 -bit and float registers
+  - 16, 32-bit and floating point registers
 
-Support functions
+Supported functions
 ---------------------------
   * Read Coils (0x01)
   * Read Discrete Inputs (0x02)
@@ -19,7 +19,7 @@ Support functions
   * Write Single Coil (0x05)
   * Write Single Register (0x06)
   * Write Multiple Coils (0x0F)
-  * Write Multiple registers (0x10)
+  * Write Multiple Registers (0x10)
   * Mask Write register (0x16)
 
 Installation
@@ -37,14 +37,14 @@ Or if you are using bundler, add to your Gemfile:
 gem 'rmodbus'
 ```
 
-If you want to use ModBus over serial, you will also need to install the 'serialport' gem.
+If you want to use ModBus over serial, you will also need to install the 'ccutrer-serialport' gem.
 If you are using bundler, add to your Gemfile:
 
 ```
-gem 'serialport'
+gem 'ccutrer-serialport'
 ```
 
-If you want to use ModBus::TCPServer or ModBus::RTUViaTCPServer and are using Ruby >= 2.2,
+If you want to use ModBus::TCPServer or ModBus::RTUViaTCPServer,
 you will also need to install the 'gserver' gem. If you are using bundler, add to your Gemfile:
 
 ```

data/examples/perfomance_rtu.rb

@@ -1,56 +1,55 @@
-$:.unshift File.join(File.dirname(__FILE__),'../lib')
-
-require 'rmodbus'
-require 'benchmark'
-
-include ModBus
-
-BAUD = 9600 
-TIMES = 100
-
-srv = RTUServer.new 'com3', BAUD 
-srv.coils = [0,1]  * 50
-srv.discrete_inputs = [1,0]  * 50
-srv.holding_registers = [0,1,2,3,4,5,6,7,8,9]  * 10
-srv.input_registers = [0,1,2,3,4,5,6,7,8,9]  * 10
-srv.start
-
-
-cl = RTUClient.new('com4', BAUD)
-cl.with_slave(1) do |slave|
-  Benchmark.bmbm do |x|
-    x.report('Read coils') do
-      TIMES.times { slave.read_coils 0, 100 }
-    end
-      
-    x.report('Read discrete inputs') do
-      TIMES.times { slave.read_discrete_inputs 0, 100 }
-    end
-    
-    x.report('Read holding registers') do
-      TIMES.times { slave.read_holding_registers 0, 100 } 
-    end
-    
-    x.report('Read input registers') do
-      TIMES.times { slave.read_input_registers 0, 100 }
-    end
-    
-    x.report('Write single coil') do
-      TIMES.times { slave.write_single_coil 0, 1 }
-    end
-    
-    x.report('Write single register') do
-      TIMES.times { slave.write_single_register 100, 0xAAAA }
-    end
-    
-    x.report('Write multiple coils') do
-      TIMES.times { slave.write_multiple_coils 0, [1,0] * 50 }
-    end
-    
-    x.report('Write multiple registers') do
-      TIMES.times { slave.write_multiple_registers 0, [0,1,2,3,4,5,6,7,8,9] * 10  }
-    end
-  end
-end
-srv.stop
-cl.close
+# frozen_string_literal: true
+
+gem "rmodbus"
+
+require "rmodbus"
+require "benchmark"
+
+BAUD = 9600
+TIMES = 100
+
+srv = ModBus::RTUServer.new "com3", BAUD
+srv.coils = [0, 1] * 50
+srv.discrete_inputs = [1, 0] * 50
+srv.holding_registers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10
+srv.input_registers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10
+srv.start
+
+cl = ModBus::RTUClient.new("com4", BAUD)
+cl.with_slave(1) do |slave|
+  Benchmark.bmbm do |x|
+    x.report("Read coils") do
+      TIMES.times { slave.read_coils 0, 100 }
+    end
+
+    x.report("Read discrete inputs") do
+      TIMES.times { slave.read_discrete_inputs 0, 100 }
+    end
+
+    x.report("Read holding registers") do
+      TIMES.times { slave.read_holding_registers 0, 100 }
+    end
+
+    x.report("Read input registers") do
+      TIMES.times { slave.read_input_registers 0, 100 }
+    end
+
+    x.report("Write single coil") do
+      TIMES.times { slave.write_single_coil 0, 1 }
+    end
+
+    x.report("Write single register") do
+      TIMES.times { slave.write_single_register 100, 0xAAAA }
+    end
+
+    x.report("Write multiple coils") do
+      TIMES.times { slave.write_multiple_coils 0, [1, 0] * 50 }
+    end
+
+    x.report("Write multiple registers") do
+      TIMES.times { slave.write_multiple_registers 0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10 }
+    end
+  end
+end
+srv.stop
+cl.close

data/examples/perfomance_rtu_via_tcp.rb

@@ -1,55 +1,54 @@
-$:.unshift File.join(File.dirname(__FILE__),'../lib')
-
-require 'rmodbus'
-require 'benchmark'
-
-include ModBus
-
-TIMES = 1000
-
-srv = ModBus::RTUViaTCPServer.new 1502 
-srv.coils = [0,1]  * 50
-srv.discrete_inputs = [1,0]  * 50
-srv.holding_registers = [0,1,2,3,4,5,6,7,8,9]  * 10
-srv.input_registers = [0,1,2,3,4,5,6,7,8,9]  * 10
-srv.start
-
-
-cl = RTUViaTCPClient.new('127.0.0.1', 1502)
-cl.with_slave(1) do |slave|
-  Benchmark.bmbm do |x|
-    x.report('Read coils') do
-      TIMES.times { slave.read_coils 0, 100 }
-    end
-    
-    x.report('Read discrete inputs') do
-      TIMES.times { slave.read_discrete_inputs 0, 100 }
-    end
-    
-    x.report('Read holding registers') do
-      TIMES.times { slave.read_holding_registers 0, 100 } 
-    end
-    
-    x.report('Read input registers') do
-      TIMES.times { slave.read_input_registers 0, 100 }
-    end
-    
-    x.report('Write single coil') do
-      TIMES.times { slave.write_single_coil 0, 1 }
-    end
-    
-    x.report('Write single register') do
-      TIMES.times { slave.write_single_register 100, 0xAAAA }
-    end
-    
-    x.report('Write multiple coils') do
-      TIMES.times { slave.write_multiple_coils 0, [1,0] * 50 }
-    end    
-    
-    x.report('Write multiple registers') do
-      TIMES.times { slave.write_multiple_registers 0, [0,1,2,3,4,5,6,7,8,9] * 10  }
-    end
-  end
-end
-cl.close
-srv.stop
+# frozen_string_literal: true
+
+gem "rmodbus"
+
+require "rmodbus"
+require "benchmark"
+
+TIMES = 1000
+
+srv = ModBus::RTUViaTCPServer.new 1502
+srv.coils = [0, 1] * 50
+srv.discrete_inputs = [1, 0] * 50
+srv.holding_registers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10
+srv.input_registers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10
+srv.start
+
+cl = ModBus::RTUClient.new("127.0.0.1", 1502)
+cl.with_slave(1) do |slave|
+  Benchmark.bmbm do |x|
+    x.report("Read coils") do
+      TIMES.times { slave.read_coils 0, 100 }
+    end
+
+    x.report("Read discrete inputs") do
+      TIMES.times { slave.read_discrete_inputs 0, 100 }
+    end
+
+    x.report("Read holding registers") do
+      TIMES.times { slave.read_holding_registers 0, 100 }
+    end
+
+    x.report("Read input registers") do
+      TIMES.times { slave.read_input_registers 0, 100 }
+    end
+
+    x.report("Write single coil") do
+      TIMES.times { slave.write_single_coil 0, 1 }
+    end
+
+    x.report("Write single register") do
+      TIMES.times { slave.write_single_register 100, 0xAAAA }
+    end
+
+    x.report("Write multiple coils") do
+      TIMES.times { slave.write_multiple_coils 0, [1, 0] * 50 }
+    end
+
+    x.report("Write multiple registers") do
+      TIMES.times { slave.write_multiple_registers 0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10 }
+    end
+  end
+end
+cl.close
+srv.stop

data/examples/perfomance_tcp.rb

@@ -1,55 +1,54 @@
-$:.unshift File.join(File.dirname(__FILE__),'../lib')
-
-require 'rmodbus'
-require 'benchmark'
-
-include ModBus
-
-TIMES = 1000
-
-srv = ModBus::TCPServer.new 1502 
-srv.coils = [0,1]  * 50
-srv.discrete_inputs = [1,0]  * 50
-srv.holding_registers = [0,1,2,3,4,5,6,7,8,9]  * 10
-srv.input_registers = [0,1,2,3,4,5,6,7,8,9]  * 10
-srv.start
-
-
-cl = TCPClient.new('127.0.0.1', 1502)
-cl.with_slave(1) do |slave|
-  Benchmark.bmbm do |x|
-    x.report('Read coils') do
-      TIMES.times { slave.read_coils 0, 100 }
-    end
-    
-    x.report('Read discrete inputs') do
-      TIMES.times { slave.read_discrete_inputs 0, 100 }
-    end
-    
-    x.report('Read holding registers') do
-      TIMES.times { slave.read_holding_registers 0, 100 } 
-    end
-    
-    x.report('Read input registers') do
-      TIMES.times { slave.read_input_registers 0, 100 }
-    end
-    
-    x.report('Write single coil') do
-      TIMES.times { slave.write_single_coil 0, 1 }
-    end
-    
-    x.report('Write single register') do
-      TIMES.times { slave.write_single_register 100, 0xAAAA }
-    end
-    
-    x.report('Write multiple coils') do
-      TIMES.times { slave.write_multiple_coils 0, [1,0] * 50 }
-    end    
-    
-    x.report('Write multiple registers') do
-      TIMES.times { slave.write_multiple_registers 0, [0,1,2,3,4,5,6,7,8,9] * 10  }
-    end
-  end
-end
-cl.close
-srv.stop
+# frozen_string_literal: true
+
+gem "rmodbus"
+
+require "rmodbus"
+require "benchmark"
+
+TIMES = 1000
+
+srv = ModBus::TCPServer.new 1502
+srv.coils = [0, 1] * 50
+srv.discrete_inputs = [1, 0] * 50
+srv.holding_registers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10
+srv.input_registers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10
+srv.start
+
+cl = ModBus::TCPClient.new("127.0.0.1", 1502)
+cl.with_slave(1) do |slave|
+  Benchmark.bmbm do |x|
+    x.report("Read coils") do
+      TIMES.times { slave.read_coils 0, 100 }
+    end
+
+    x.report("Read discrete inputs") do
+      TIMES.times { slave.read_discrete_inputs 0, 100 }
+    end
+
+    x.report("Read holding registers") do
+      TIMES.times { slave.read_holding_registers 0, 100 }
+    end
+
+    x.report("Read input registers") do
+      TIMES.times { slave.read_input_registers 0, 100 }
+    end
+
+    x.report("Write single coil") do
+      TIMES.times { slave.write_single_coil 0, 1 }
+    end
+
+    x.report("Write single register") do
+      TIMES.times { slave.write_single_register 100, 0xAAAA }
+    end
+
+    x.report("Write multiple coils") do
+      TIMES.times { slave.write_multiple_coils 0, [1, 0] * 50 }
+    end
+
+    x.report("Write multiple registers") do
+      TIMES.times { slave.write_multiple_registers 0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10 }
+    end
+  end
+end
+cl.close
+srv.stop

data/examples/simple_xpca_gateway.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# It's very simple example of implementation XPCA gateway (see http://www.xpca.org)
+# for communication with TCP ModBus devices
+# It receives  REST requests (e.g http://127.0.0.1:4567/mb/127.0.0.1/8502/1/coils/6/17 )
+# and returns data in JSON format addr : data:
+# {"coils": {
+#   "6":{
+#     "value":0,
+#     "timestamp":"2011-07-12 18:11:03 +0000",
+#     "quality":"good"
+#   },
+#   "7":{
+#     "value":0,
+#     "timestamp":"2011-07-12 18:11:03 +0000",
+#     "quality":"good"
+#     }
+#   ...
+# }
+#
+# This code requies gems: rmodbus, sinatra and json
+# 2011 (c) Aleksey Timin
+
+gem "rmodbus"
+gem "sinatra"
+
+require "rmodbus"
+require "sinatra"
+require "json"
+
+# Launche TCP ModBus server for test
+IP = "127.0.0.1"
+PORT = 8502
+
+@srv = ModBus::TCPServer.new(PORT, 1)
+
+@srv.holding_registers = Array.new(100) { |i| i + 1 }
+@srv.input_registers = Array.new(100) { |i| i + 1 }
+@srv.coils = Array.new(100) { 0 }
+@srv.discrete_inputs = Array.new(100) { 0 }
+
+@srv.start
+
+# Calc a GET request
+# @example
+# http://127.0.0.1:4567/mb/127.0.0.1/8502/1/coils/6/17
+#
+# HTTP route: GET http://localhost/mb/:ip/:port/:slave/:dataplace/:firstaddr/:lastaddr
+#
+# :ip - ip addr of ModBus TCP Server
+# :port - port of ModBUs TCP Server
+# :slave - id of slave device
+# :dataplace - valid values: coils, discrete_inputs, input_registers, holding_registers
+# :firstaddr - first addr of registers(contacts)
+# :lastaddr - last addr of registers(contacts)
+get "/mb/:ip/:port/:slave/:dataplace/:firstaddr/:lastaddr" do
+  resp = {}
+  begin
+    data = []
+    ModBus::TCPClient.new(params[:ip].to_s, params[:port].to_i) do |cl|
+      cl.with_slave(params[:slave].to_i) do |slave|
+        slave.debug = true
+        dataplace = slave.send params[:dataplace]
+        data = dataplace[params[:firstaddr].to_i..params[:lastaddr].to_i]
+      end
+    end
+
+    resp = { params[:dataplace] => {} }
+    data.each_with_index do |v, i|
+      resp[params[:dataplace]][params[:firstaddr].to_i + i] = {
+        value: v,
+        timestamp: Time.now.utc.strftime("%Y-%m-%d %H:%M:%S %z"),
+        quality: "good"
+      }
+    end
+  rescue => e
+    resp = { error: {
+      type: e.class,
+      message: e.message
+    } }
+  end
+
+  content_type "application/json"
+  resp.to_json
+end

data/examples/use_rtu_via_tcp_modbus.rb

@@ -1,21 +1,24 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib/')
-require 'rmodbus'
+# frozen_string_literal: true
 
-srv = ModBus::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]
+gem "rmodbus"
+
+require "rmodbus"
+
+srv = ModBus::RTUViaTCPServer.new(10_002, 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
 
-ModBus::RTUViaTCPClient.connect('127.0.0.1', 10002) do |cl|
+ModBus::RTUClient.connect("127.0.0.1", 10_002) do |cl|
   cl.with_slave(1) do |slave|
     slave.debug = true
     regs = slave.holding_registers
-  	puts regs[0..3]
-  	regs[0..3] = [2,0,1,1]
-  	puts regs[0..3]
+    puts regs[0..3]
+    regs[0..3] = [2, 0, 1, 1]
+    puts regs[0..3]
   end
 end
 

data/examples/use_tcp_modbus.rb

@@ -1,22 +1,25 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib/')
-require 'rmodbus'
+# frozen_string_literal: true
 
-srv = ModBus::TCPServer.new(8502,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]
+gem "rmodbus"
+
+require "rmodbus"
+
+srv = ModBus::TCPServer.new(8502, 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.audit = true
 srv.start
 
-ModBus::TCPClient.connect('127.0.0.1', 8502) do |cl|
+ModBus::TCPClient.connect("127.0.0.1", 8502) do |cl|
   cl.with_slave(1) do |slave|
     slave.debug = true
     regs = slave.holding_registers
-  	puts regs[0..3]
-  	regs[0..3] = [2,0,1,1]
-  	puts regs[0..3]
+    puts regs[0..3]
+    regs[0..3] = [2, 0, 1, 1]
+    puts regs[0..3]
   end
 end