rmodbus-ccutrer 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3f1eb7faa783c285b4152b693b9f2ea3b9639917e589714b4bea416e483998e
-  data.tar.gz: 0e9005770dab3ca0336583e59a9c1c7d098b11267199a83e1d65339b7bd68a6c
+  metadata.gz: 54f263da20a19a21775020577dce25e7a2aaca41275aeb2c29c68375da47bca6
+  data.tar.gz: 4beee65023368ae9e8ecfd8718053b0eaf2c47499a16093c7b657f00c64a386b
 SHA512:
-  metadata.gz: 8ee2ba1774e37c5e111fc0242056a5c8fb3cb3cec0b7243782e54f06e7c9d0d4e595bc51b7c1e9dea13f7d93b52ce83a2d23eec252f22c7e24e57df34e166fb7
-  data.tar.gz: 5c4732bd7e8edbd18e8cffb942911d5c7cf161beb8c0935fbb2ed521505adfe607fe46dc6f80e8ea74cb6c1a5f36641f52364f43eb51c06cf90a77df50f1683e
+  metadata.gz: 3dc1260c7f4f622c682b4b4704f24ecbe402c9fee957bc047b2dd6b30c523f8269686a54453fb35a3bc920fa69753cba30056a7f6aa880fdbcc5c347151d7c7f
+  data.tar.gz: b660d80c3933219e3073cc3d24b70eae233828db333154559d5a7897fd40166af31dd6a64af8c946a8b86ae4e4331274a5abfe149f19ffab0721e73b905fe404

data/NEWS.md

@@ -1,14 +1,21 @@
-###UPCOMING
+###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.
-3. Don't time out waiting to read a response that will never come from broadcast commands
-4. Don't send responses to broadcast commands as a server
-5. Properly function as a server in an environment with multiple RTU slaves
-6. Server now supports promiscuous mode to dump the conversation happening between a master and other slaves.
-7. Add read/write multiple registers function (server and client)
-8. Add mask write register function to server
+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
 

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 = 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
+# 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::RTUClient.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