modbus-cli 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.*swp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in modbus-cli.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,212 @@
+modbus-cli
+==========
+
+modbus-cli is a command line utility that lets you read and write data using
+the Modbus TCP protocol (ethernet only, no serial line). It supports different
+data formats (bool, int, word, float, dword), allows you to save data to a file
+and dump it back to your device, acting as a backup tool, or allowing you to
+move blocks in memory.
+
+[Home page]:http://www.github.com/tallakt/momdbus-cli
+
+Installation
+------------
+
+Install ruby. Then install the gem:
+
+    $ gem install modbus-cli
+
+The pure ruby gem should run on most rubies.
+
+Quick Start
+-----------
+
+Lets start by reading five words from our device startig from address %MW100. 
+
+    $ modbus read 192.168.0.1 %MW100 5
+
+which writes
+
+    %MW100        0
+    %MW101        0
+    %MW102        0
+    %MW103        0
+    %MW104        0
+
+We chose to write the address in Schneider format, %MW100, but you can also use Modicon naming convention.
+The following achieves the same as the previous line
+
+    $ modbus read 192.168.0.1 400101 5
+
+To read coils run the command
+
+    $ modbus read 192.168.0.1 %M100 5
+
+or 
+
+    $ modbus read 192.168.0.1 101 5
+
+You get three subcommands, read, write and dump. The dump commands writes data previously read
+using the read command back to its original location. You can get more info on the commands by 
+using the help parameter
+
+    $ modbus read --help
+ 
+To write data, write the values after the offset
+
+    $ modbus write 192.168.0.1 101 1 2 3 4 5
+
+Please be aware that there is no protection here - you could easily mess up a running production
+system by doing this.
+
+Data Types
+----------
+
+For Schneider format you can choose between different data types by using different addresses, 
+When using Modicon addresses, you may specify the data type with an additional parameter.
+The supported data types are shown in the following table
+
+<table>
+  <tr>
+    <th>Data type</th>
+    <th>Data size</th>
+    <th>Schneider address</th>
+    <th>Modicon address</th>
+    <th>Parameter</th>
+  </tr>
+  <tr>
+    <td>word (default, unsigned)</td>
+    <td>16 bits</td>
+    <td>%MW100</td>
+    <td>400101</td>
+    <td>--word</td>
+  </tr>
+  <tr>
+    <td>integer (signed)</td>
+    <td>16 bits</td>
+    <td>%MW100</td>
+    <td>400101</td>
+    <td>--int</td>
+  </tr>
+  <tr>
+    <td>floating point</td>
+    <td>32 bits</td>
+    <td>%MF100</td>
+    <td>400101</td>
+    <td>--float</td>
+  </tr>
+  <tr>
+    <td>double word</td>
+    <td>32 bits</td>
+    <td>%MD100</td>
+    <td>400101</td>
+    <td>--dword</td>
+  </tr>
+  <tr>
+    <td>boolean (coils)</td>
+    <td>1 bit</td>
+    <td>%M100</td>
+    <td>101</td>
+    <td>N/A</td>
+  </tr>
+</table>
+
+To read a floating point value, issue the following command
+
+    $ modbus read %MF100 2
+
+which should give you something like
+
+    %MF100    0.0
+    %MF102    0.0
+
+or alternatively
+
+    $ modbus read --float 400101 2
+
+giving
+
+    400101   0.0
+    400103   0.0
+
+The modbus command supports the addressing areas 1..99999 for coils and 400001..499999 for the rest using Modicon addresses. Using Schneider addresses the %M addresses are in a separate memory from %MW values, but %MW, %MD, %MF all reside in a shared memory, so %MW0 and %MW1 share the memory with %MF0.
+
+
+Reading and dumping to files
+----------------------------
+
+The following functionality has a few potential uses:
+
+* Storing a backup of PLC memory containing setpoints and such in event og hardware failure
+* Moving a block from one location in the PLC to another location
+* Copy data from one machine to another
+
+First, start by reading data from your device to be stored in a file
+
+    $ modbus read --output mybackup.yml 192.168.0.1 400001 1000
+
+on Linux you may want to look at the text file by doing
+
+    $ less mybackup.yml
+
+on Windows try loading the file in Wordpad.
+
+To restore the memory at a later time, run the command (again a word of warning, this can mess
+up a running production system)
+
+    $ modbus dump mybackup.yml
+
+The modbus command supports multiple files, so feel free to write
+
+    $ modbus dump *.yml
+
+To write the data back to a different device, use the --host parameter
+
+    $ modbus dump --host 192.168.0.2 mybackup.yml
+
+or for a different memory location
+
+    $ modbus dump --offset 401001 192.168.0.2 mybackup.yml
+
+or for a different slave id
+
+    $ modbus dump --slave 88 192.168.0.2 mybackup.yml
+
+Slave ids are not commonly necessary when working with Modbus TCP.
+
+Contributing to modbus-cli
+--------------------------
+
+Feel free to fork the project on GitHub and send fork requests. Please 
+try to have each feature separated in commits.
+
+
+
+License
+-------
+
+    (The MIT License)
+
+    Copyright (C) 2011 Tallak Tveide
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to
+    deal in the Software without restriction, including without limitation the
+    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+    sell copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/bin/modbus

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+
+require 'modbus-cli'
+
+Modbus::Cli::CommandLineRunner.run
+

data/lib/modbus-cli.rb

@@ -0,0 +1,33 @@
+require 'clamp'
+
+# do it this way to not have serialport warning on startup
+# require 'rmodbus'
+require 'rmodbus/errors'
+require 'rmodbus/ext'
+require 'rmodbus/debug'
+require 'rmodbus/options'
+require 'rmodbus/rtu'
+require 'rmodbus/tcp'
+require 'rmodbus/slave'
+require 'rmodbus/client'
+require 'rmodbus/server'
+require 'rmodbus/tcp_slave'
+require 'rmodbus/tcp_client'
+require 'rmodbus/tcp_server'
+
+require 'modbus-cli/version'
+require 'modbus-cli/read_command'
+require 'modbus-cli/write_command'
+require 'modbus-cli/dump_command'
+
+module Modbus
+  module Cli
+    DEFAULT_SLAVE = 1
+
+    class CommandLineRunner < Clamp::Command
+      subcommand 'read', 'read from the device', ReadCommand
+      subcommand 'write', 'write to the device', WriteCommand
+      subcommand 'dump', 'copy contents of read file to the device', DumpCommand
+    end
+  end
+end

data/lib/modbus-cli/commands_common.rb

@@ -0,0 +1,130 @@
+module Modbus
+  module Cli
+    module CommandsCommon
+      
+      MAX_WRITE_COILS = 1968
+      MAX_WRITE_WORDS = 123
+      DEFAULT_SLAVE = 1
+
+      module ClassMethods
+
+        def host_parameter
+          parameter 'HOST', 'IP address or hostname for the Modbus device', :attribute_name => :host
+        end
+
+
+        def address_parameter
+          parameter 'ADDRESS', 'Start address, in Schneider format (eg %M100, %MW100)', :attribute_name => :address do |a|
+            schneider_match(a) || modicon_match(a) || raise(ArgumentError, "Illegal address #{a}")
+          end
+        end
+
+        def datatype_options
+          option ["-w", "--word"], :flag, "use signed 16 bit integers"
+          option ["-i", "--int"], :flag, "use signed 16 bit integers"
+          option ["-d", "--dword"], :flag, "use signed 16 bit integers"
+          option ["-f", "--float"], :flag, "use signed 16 bit integers"
+        end
+
+        def format_options
+          option ["--modicon"], :flag, "use Modicon addressing (eg. coil: 101, word: 400001)"
+          option ["--schneider"], :flag, "use Schneider addressing (eg. coil: %M100, word: %MW0, float: %MF0, dword: %MD0)"
+        end
+
+        def slave_option
+          option ["-s", "--slave"], 'ID', "use slave id ID", :default => 1 do |s|
+            Integer(s).tap {|slave| raise ArgumentError 'Slave must be in the range 0..255' unless (0..255).member?(slave) }
+          end
+        end
+
+        def output_option
+        end
+      end
+
+
+      def data_size
+        case addr_type
+        when :bit, :word, :int
+          1
+        when :float, :dword
+          2
+        end
+      end
+
+
+      def addr_offset
+        address[:offset]
+      end
+
+      def addr_type
+        if int?
+          :int
+        elsif dword?
+          :dword
+        elsif float?
+          :float
+        elsif word?
+          :word
+        else
+          address[:datatype]
+        end
+      end
+
+
+      def schneider_match(address)
+        schneider_match =  address.match /%M([FWD])?(\d+)/i
+        if schneider_match
+          {:offset => schneider_match[2].to_i, :format => :schneider}.tap do |result|
+            case schneider_match[1]
+            when nil
+              result[:datatype] = :bit
+            when 'W', 'w'
+              result[:datatype] = :word
+            when 'F', 'f'
+              result[:datatype] = :float
+            when 'D', 'd'
+              result[:datatype] = :dword
+            end
+          end
+        end
+      end
+
+
+      def modicon_match(address)
+        if address.match /^\d+$/ 
+          offset = address.to_i
+          case offset
+          when 1..99999
+            {:offset => offset - 1, :datatype => :bit, :format => :modicon}
+          when 400001..499999
+            {:offset => offset - 400001, :datatype => :word, :format => :modicon}
+          end
+        end
+      end
+
+      def addr_format
+        if schneider?
+          :schneider
+        elsif modicon?
+          :modicon
+        else
+          address[:format]
+        end
+      end
+
+      def sliced_write_registers(sl, offset, data)
+        (0..(data.count - 1)).each_slice(MAX_WRITE_WORDS) do |slice|
+          result = sl.write_holding_registers(slice.first + offset, data.values_at(*slice))
+        end
+      end
+
+      def sliced_write_coils(sl, offset, data)
+        (0..(data.count - 1)).each_slice(MAX_WRITE_COILS) do |slice|
+          result = sl.write_multiple_coils(slice.first + offset, data.values_at(*slice))
+        end
+      end
+
+    end
+  end
+end
+

data/lib/modbus-cli/dump_command.rb

@@ -0,0 +1,64 @@
+require 'modbus-cli/commands_common'
+require 'yaml'
+
+module Modbus
+  module Cli
+    class DumpCommand < Clamp::Command
+      extend CommandsCommon::ClassMethods
+      include CommandsCommon
+
+      parameter 'FILES ...', 'restore data in FILES to original devices (created by modbus read command)', :attribute_name => :files do |f|
+        f.map do |filename| 
+          YAML.load_file(filename).dup.tap do |ff|
+            #parameter takes presedence
+            ff[:host] = host || ff[:host]
+            ff[:slave] = slave || ff[:slave]
+            ff[:offset] = offset || ff[:offset]
+          end
+        end
+      end
+
+      option ["-h", "--host"], 'ADDR', "use the address/hostname ADDR instead of the stored one"
+
+      option ["-s", "--slave"], 'ID', "use slave ID instead of the stored one" do |s|
+        Integer(s).tap {|slave| raise ArgumentError 'Slave address should be in the range 0..255' unless (0..255).member? slave }
+      end
+
+      option ["-o", "--offset"], 'OFFSET', "start writing at address OFFSET instead of original location" do |o|
+        raise ArgumentError 'Illegal offset address: ' + o unless modicon_match(o) || schneider_match(o)
+        o
+      end
+
+      def execute
+        host_ids = files.map {|d| d[:host] }.sort.uniq
+        host_ids.each {|host_id| execute_host host_id }
+      end
+
+      def execute_host(host_id)
+        slave_ids =   files.select {|d| d[:host] == host_id }.map {|d| d[:slave] }.sort.uniq
+        ModBus::TCPClient.connect(host_id) do |client|
+          slave_ids.each {|slave_id| execute_slave host_id, slave_id, client }
+        end
+      end
+
+      def execute_slave(host_id, slave_id, client)
+        client.with_slave(slave_id) do |slave|
+            files.select {|d| d[:host] == host_id && d[:slave] == slave_id }.each do |file_data|
+            execute_single_file slave, file_data
+          end
+        end
+      end
+
+      def execute_single_file(slave, file_data)
+        address = modicon_match(file_data[:offset].to_s) || schneider_match(file_data[:offset].to_s)
+        case address[:datatype]
+        when :bit
+          sliced_write_coils slave, address[:offset], file_data[:data]
+        when :word
+          sliced_write_registers slave, address[:offset], file_data[:data]
+        end
+      end
+    end
+  end
+end
+

data/lib/modbus-cli/read_command.rb

@@ -0,0 +1,160 @@
+require 'modbus-cli/commands_common'
+require 'yaml'
+
+module Modbus
+  module Cli
+    class ReadCommand < Clamp::Command
+      extend CommandsCommon::ClassMethods
+      include CommandsCommon
+
+      MAX_READ_COIL_COUNT = 2000
+      MAX_READ_WORD_COUNT = 125
+
+      datatype_options
+      format_options
+      slave_option
+      host_parameter
+      address_parameter
+      option ["-o", "--output"], 'FILE', "write results to file FILE"
+      
+      parameter 'COUNT', 'number of data to read', :attribute_name => :count do |c|
+        result = Integer(c)
+        raise ArgumentError, 'Count must be positive' if result <= 0
+        result
+
+      end
+
+      def read_floats(sl)
+        floats = read_and_unpack(sl, 'g')
+        (0...count).each do |n|
+          puts "#{ '%-10s' % address_to_s(addr_offset + n * data_size)} #{nice_float('% 16.8f' % floats[n])}"
+        end
+      end
+
+      def read_dwords(sl)
+        dwords = read_and_unpack(sl, 'N')
+        (0...count).each do |n|
+          puts "#{ '%-10s' % address_to_s(addr_offset + n * data_size)} #{'%10d' % dwords[n]}"
+        end
+      end
+
+      def read_registers(sl, options = {})
+        data = read_data_words(sl)
+        if options[:int]
+          data = data.pack('S').unpack('s')
+        end
+        read_range.zip(data).each do |pair|
+          puts "#{ '%-10s' % address_to_s(pair.first)} #{'%6d' % pair.last}"
+        end
+      end
+
+      def read_words_to_file(sl)
+        write_data_to_file(read_data_words(sl))
+      end
+
+      def read_coils_to_file(sl)
+        write_data_to_file(read_data_coils(sl))
+      end
+
+      def write_data_to_file(data)
+        File.open(output, 'w') do |file|
+          file.puts({ :host => host, :slave => slave, :offset => address_to_s(addr_offset, :modicon), :data => data }.to_yaml)
+        end
+      end
+
+      def read_coils(sl)
+        data = read_data_coils(sl)
+        read_range.zip(data) do |pair|
+          puts "#{ '%-10s' % address_to_s(pair.first)} #{'%d' % pair.last}"
+        end
+      end
+
+      def execute
+        ModBus::TCPClient.connect(host) do |cl|
+          cl.with_slave(slave) do |sl|
+            if output then
+              case addr_type
+              when :bit
+                read_coils_to_file(sl)
+              else
+                read_words_to_file(sl)
+              end
+            else
+              case addr_type
+              when :bit
+                read_coils(sl)
+              when :int
+                read_registers(sl, :int => true)
+              when :word
+                read_registers(sl)
+              when :float
+                read_floats(sl)
+              when :dword
+                read_dwords(sl)
+              end
+            end
+          end
+        end
+      end
+
+      def read_and_unpack(sl, format)
+        # the word ordering is wrong. calling reverse two times effectively swaps every pair
+        read_data_words(sl).reverse.pack('n*').unpack("#{format}*").reverse
+      end
+
+      def read_data_words(sl)
+        result = []
+        read_range.each_slice(MAX_READ_WORD_COUNT) {|slice| result += sl.read_holding_registers(slice.first, slice.count) }
+        result
+      end
+
+
+      def read_data_coils(sl)
+        result = []
+        read_range.each_slice(MAX_READ_COIL_COUNT) do |slice|
+          result += sl.read_coils(slice.first, slice.count)
+        end
+        result
+      end
+
+      def read_range
+        (addr_offset..(addr_offset + count * data_size - 1))
+      end
+
+
+      def nice_float(str)
+        m = str.match /(.*[.][0-9])0*/
+        if m
+          m[1]
+        else
+          str
+        end
+      end
+
+      def address_to_s(addr, format = addr_format)
+        case format
+        when :schneider
+          case addr_type
+          when :bit
+            '%M' + addr.to_s
+          when :word, :int
+            '%MW' + addr.to_s
+          when :dword
+            '%MD' + addr.to_s
+          when :float
+            '%MF' + addr.to_s
+          end
+        when :modicon
+          case addr_type
+          when :bit
+            (addr + 1).to_s
+          when :word, :int
+            (addr + 400001).to_s
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/modbus-cli/version.rb

@@ -0,0 +1,5 @@
+module Modbus
+  module Cli
+    VERSION = "0.0.1"
+  end
+end

data/lib/modbus-cli/write_command.rb

@@ -0,0 +1,81 @@
+require 'modbus-cli/commands_common'
+
+module Modbus
+  module Cli
+    class WriteCommand < Clamp::Command
+      extend CommandsCommon::ClassMethods
+      include CommandsCommon
+
+
+      datatype_options
+      format_options
+      slave_option
+      host_parameter
+      address_parameter
+
+      parameter 'VALUES ...', 'values to write, nonzero counts as true for discrete values', :attribute_name => :values do |vv|
+        case addr_type
+
+        when :bit
+          int_parameter vv, 0, 1
+        when :word
+          int_parameter vv, 0, 0xffff
+        when :int
+          int_parameter vv, -32768, 32767
+        when :dword
+          int_parameter vv, 0, 0xffffffff
+        when :float
+          vv.map {|v| Float(v) }
+        end
+      end
+
+
+
+      def execute
+        ModBus::TCPClient.connect(host) do |cl|
+          cl.with_slave(slave) do |sl|
+            case addr_type
+            when :bit
+              write_coils sl
+            when :word, :int
+              write_words sl
+            when :float
+              write_floats sl
+            when :dword
+              write_dwords sl
+            end
+          end
+        end
+      end
+
+      def write_coils(sl)
+        sliced_write_coils sl, addr_offset, values
+      end
+
+      def write_words(sl)
+        sliced_write_registers sl, addr_offset, values.pack('S*').unpack('S*')
+      end
+
+      def write_floats(sl)
+        pack_and_write sl, 'g'
+      end
+
+      def write_dwords(sl)
+        pack_and_write sl, 'N'
+      end
+
+      def pack_and_write(sl, format)
+        # the word ordering is wrong. calling reverse two times effectively swaps every pair
+        sliced_write_registers(sl, addr_offset, values.reverse.pack("#{format}*").unpack('n*').reverse)
+      end
+
+      def int_parameter(vv, min, max)
+        vv.map {|v| Integer(v) }.tap do |values|
+          values.each do |v|
+            raise ArgumentError, "Value should be in the range #{min}..#{max}" unless (min..max).member? v
+          end
+        end
+      end
+    end
+  end
+end

data/modbus-cli.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "modbus-cli/version"
+
+Gem::Specification.new do |s|
+  s.name        = "modbus-cli"
+  s.version     = Modbus::Cli::VERSION
+  s.authors     = ["Tallak Tveide"]
+  s.email       = ["tallak@tveide.net"]
+  s.homepage    = "http://www.github.com/tallakt/modbus-cli"
+  s.summary     = %q{Modbus command line}
+  s.description = %q{Command line interface to communicate over Modbus TCP}
+
+  s.rubyforge_project = "modbus-cli"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "rmodbus", '= 1.1.0'
+  s.add_runtime_dependency "clamp", '= 0.3.0'
+  s.add_development_dependency "rspec", '= 2.7.0'
+end

data/spec/dump_command_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+
+
+describe Modbus::Cli::DumpCommand do
+  before(:each) do
+    stub_tcpip
+  end
+
+  it 'reads the file and write the contents to the original device' do
+    client = mock 'client'
+    slave = mock 'slave'
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 400123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    client.should_receive(:with_slave).with(5).and_yield(slave)
+    slave.should_receive(:write_holding_registers).with(122, [4, 5, 6])
+    cmd.run %w(dump dump.yml)
+  end
+
+  it 'can read two files from separate hosts' do
+    client1 = mock 'client1'
+    client2 = mock 'client2'
+    slave1 = mock 'slave1'
+    slave2 = mock 'slave2'
+    yml = {:host => 'X', :slave => 5, :offset => 400010, :data => [99]}
+    YAML.should_receive(:load_file).with('a.yml').and_return(yml)
+    YAML.should_receive(:load_file).with('b.yml').and_return(yml.dup.tap {|y| y[:host] = 'Y' })
+    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client1)
+    ModBus::TCPClient.should_receive(:connect).with('Y').and_yield(client2)
+    client1.should_receive(:with_slave).with(5).and_yield(slave1)
+    client2.should_receive(:with_slave).with(5).and_yield(slave2)
+    slave1.should_receive(:write_holding_registers).with(9, [99])
+    slave2.should_receive(:write_holding_registers).with(9, [99])
+    cmd.run %w(dump a.yml b.yml)
+  end
+
+  it 'can dump two files from separate slaves on same host' do
+    client1 = mock 'client1'
+    slave1 = mock 'slave1'
+    slave2 = mock 'slave2'
+    yml = {:host => 'X', :slave => 5, :offset => 400010, :data => [99]}
+    YAML.should_receive(:load_file).with('a.yml').and_return(yml)
+    YAML.should_receive(:load_file).with('b.yml').and_return(yml.dup.tap {|y| y[:slave] = 99 })
+    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client1)
+    client1.should_receive(:with_slave).with(5).and_yield(slave1)
+    client1.should_receive(:with_slave).with(99).and_yield(slave2)
+    slave1.should_receive(:write_holding_registers).with(9, [99])
+    slave2.should_receive(:write_holding_registers).with(9, [99])
+    cmd.run %w(dump a.yml b.yml)
+  end
+
+  it 'can dump two files from one slave' do
+    client1 = mock 'client1'
+    slave1 = mock 'slave1'
+    yml = {:host => 'X', :slave => 5, :offset => 400010, :data => [99]}
+    YAML.should_receive(:load_file).with('a.yml').and_return(yml)
+    YAML.should_receive(:load_file).with('b.yml').and_return(yml.dup)
+    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client1)
+    client1.should_receive(:with_slave).with(5).and_yield(slave1)
+    slave1.should_receive(:write_holding_registers).with(9, [99])
+    slave1.should_receive(:write_holding_registers).with(9, [99])
+    cmd.run %w(dump a.yml b.yml)
+  end
+
+  it 'accepts the --host <hostname> parameter' do
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('Y')
+    cmd.run %w(dump --host Y dump.yml)
+  end
+
+  it 'accepts the --slave <id> parameter' do
+    client = mock 'client'
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    client.should_receive(:with_slave).with(99)
+    cmd.run %w(dump --slave 99 dump.yml)
+  end
+
+  it 'accepts the --offset <n> parameter with modicon addressing' do
+    client = mock 'client'
+    slave = mock 'slave'
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    client.should_receive(:with_slave).with(5).and_yield(slave)
+    slave.should_receive(:write_holding_registers).with(100, [4, 5, 6])
+    cmd.run %w(dump --offset 400101 dump.yml)
+  end
+
+  it 'accepts the --offset <n> parameter with schneider addressing' do
+    client = mock 'client'
+    slave = mock 'slave'
+    YAML.should_receive(:load_file).with('dump.yml').and_return(:host => '1.2.3.4', :slave => 5, :offset => 123, :data => [4, 5, 6])
+    ModBus::TCPClient.should_receive(:connect).with('1.2.3.4').and_yield(client)
+    client.should_receive(:with_slave).with(5).and_yield(slave)
+    slave.should_receive(:write_holding_registers).with(100, [4, 5, 6])
+    cmd.run %w(dump --offset %MW100 dump.yml)
+  end
+end
+
+
+
+
+
+

data/spec/modbus_cli_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+
+
+describe Modbus::Cli::CommandLineRunner do
+	include OutputCapture
+
+  before(:each) do
+    stub_tcpip
+  end
+
+  it 'has help describing the read and write commands' do
+    c = cmd
+    Proc.new { c.run(%w(--help)) }.should raise_exception(Clamp::HelpWanted)
+    c.help.should match /usage:/i
+    c.help.should match /read/
+    c.help.should match /write/
+    c.help.should match /dump/
+  end
+end
+
+
+
+

data/spec/read_command_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+require 'yaml'
+
+
+
+describe Modbus::Cli::ReadCommand do
+	include OutputCapture
+
+  before(:each) do
+    stub_tcpip
+  end
+
+  it 'can read registers' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
+    cmd.run %w(read 1.2.3.4 %MW100 10)
+    stdout.should match(/^\s*%MW105\s*5$/)
+  end
+
+
+  it 'can read floating point numbers' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 4).and_return([52429, 17095, 52429, 17095])
+    cmd.run %w(read 1.2.3.4 %MF100 2)
+    stdout.should match(/^\s*%MF102\s*99[.]9(00[0-9]*)?$/)
+  end
+
+  it 'can read double word numbers' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 4).and_return([16959, 15, 16959, 15])
+    cmd.run %w(read 1.2.3.4 %MD100 2)
+    stdout.should match(/^\s*%MD102\s*999999$/)
+  end
+
+  it 'can read coils' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_coils).with(100, 10).and_return([1, 0] * 5)
+    cmd.run %w(read 1.2.3.4 %M100 10)
+    stdout.should match(/^\s*%M105\s*0$/)
+  end
+
+
+
+
+  it 'rejects illegal counts' do
+    lambda { cmd.run %w(read 1.2.3.4 %MW100 1+0) }.should raise_exception(Clamp::UsageError)
+    lambda { cmd.run %w(read 1.2.3.4 %MW100 -10) }.should raise_exception(Clamp::UsageError)
+    lambda { cmd.run %w(read 1.2.3.4 %MW100 9.9) }.should raise_exception(Clamp::UsageError)
+  end
+
+  it 'rejects illegal addresses' do
+    lambda { cmd.run %w(read 1.2.3.4 %MW1+00) }.should raise_exception(Clamp::UsageError)
+  end
+
+  it 'should split large reads into smaller chunks for words' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 125).and_return([1, 0] * 1000)
+    slave.should_receive(:read_holding_registers).with(225, 25).and_return([1, 0] * 1000)
+    cmd.run %w(read 1.2.3.4 %MW100 150)
+  end
+
+  it 'should split large reads into smaller chunks for coils' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_coils).with(100, 2000).and_return([1, 0] * 1000)
+    slave.should_receive(:read_coils).with(2100, 1000).and_return([1, 0] * 500)
+    cmd.run %w(read 1.2.3.4 %M100 3000)
+  end
+
+  it 'can read registers as ints' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 1).and_return([0xffff])
+    cmd.run %w(read --int 1.2.3.4 %MW100 1)
+    stdout.should match(/^\s*%MW100\s*-1$/)
+  end
+
+  it 'can read registers as floats' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 2).and_return([0,0])
+    cmd.run %w(read --float 1.2.3.4 %MW100 1)
+  end
+
+  it 'can read registers as dwords' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 2).and_return([0,0])
+    cmd.run %w(read --dword 1.2.3.4 %MW100 1)
+  end
+
+  it 'can read registers as words' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 1).and_return([0])
+    cmd.run %w(read --word 1.2.3.4 %MD100 1)
+  end
+
+  it 'accepts Modicon addresses for coils' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_coils).with(100, 10).and_return([1, 0] * 5)
+    cmd.run %w(read 1.2.3.4 101 10)
+    stdout.should match(/^\s*106\s*0$/)
+  end
+
+  it 'accepts Modicon addresses for registers' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
+    cmd.run %w(read 1.2.3.4 400101 10)
+    stdout.should match(/^\s*400106\s*5$/)
+  end
+
+
+  it 'should accept the --modicon option to force modicon output' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
+    cmd.run %w(read --modicon 1.2.3.4 %MW100 10)
+    stdout.should match(/^\s*400106\s*5$/)
+  end
+
+  it 'should accept the --schneider option to force schneider output' do 
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 10).and_return((0..9).to_a)
+    cmd.run %w(read --schneider 1.2.3.4 400101 10)
+    stdout.should match(/^\s*%MW105\s*5$/)
+  end
+
+  it 'has a --slave parameter' do
+    client = mock 'client'
+    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client)
+    client.should_receive(:with_slave).with(99)
+    cmd.run %w(read --slave 99 X 101 1)
+  end
+
+  it 'can write the output from reading registers to a yaml file using the -o <filename> parameter' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_holding_registers).with(100, 1).and_return([1])
+    file_mock = mock('file')
+    File.should_receive(:open).and_yield(file_mock)
+    file_mock.should_receive(:puts).with({:host => '1.2.3.4', :slave => 1, :offset => '400101', :data => [1]}.to_yaml)
+    cmd.run %w(read --output filename.yml 1.2.3.4 %MW100 1)
+    stdout.should_not match(/./)
+  end
+
+  it 'can write the output from reading coils to a yaml file using the -o <filename> parameter' do
+    client, slave = standard_connect_helper '1.2.3.4'
+    slave.should_receive(:read_coils).with(100, 1).and_return([1])
+    file_mock = mock('file')
+    File.should_receive(:open).and_yield(file_mock)
+    file_mock.should_receive(:puts).with({:host => '1.2.3.4', :slave => 1, :offset => '101', :data => [1]}.to_yaml)
+    cmd.run %w(read --output filename.yml 1.2.3.4 %M100 1)
+    stdout.should_not match(/./)
+  end
+
+
+end
+
+
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'rspec'
+require 'clamp'
+require 'stringio'
+require 'modbus-cli'
+
+# Borrowed from Clamp tests
+module OutputCapture
+
+  def self.included(target)
+    target.before do
+      $stdout = @out = StringIO.new
+      $stderr = @err = StringIO.new
+    end
+    target.after do
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+  end
+
+  def stdout
+    @out.string
+  end
+
+  def stderr
+    @err.string
+  end
+
+
+
+end
+
+def stub_tcpip
+  TCPSocket.stub!(:new) # prevent comms with actual PLC or device
+end
+
+
+def standard_connect_helper(address)
+  client = mock 'client'
+  slave = mock 'slave'
+  ModBus::TCPClient.should_receive(:connect).with(address).and_yield(client)
+  client.should_receive(:with_slave).with(1).and_yield(slave)
+  return client, slave
+end
+
+
+def cmd
+ Modbus::Cli::CommandLineRunner.new('modbus-cli') 
+end

data/spec/write_command_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+
+
+describe Modbus::Cli::WriteCommand do
+	include OutputCapture
+
+  before(:each) do
+    stub_tcpip
+  end
+
+  it 'can write to registers' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [1, 2, 3, 4])
+    cmd.run %w(write HOST %MW100 1 2 3 4)
+  end
+
+
+  it 'can write floating point numbers' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [52429, 17095, 52429, 17095])
+    cmd.run %w(write HOST %MF100 99.9 99.9)
+  end
+
+  it 'can write double word numbers' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [16959, 15, 16959, 15])
+    cmd.run %w(write HOST %MD100 999999 999999)
+  end
+
+  it 'can write to coils' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_multiple_coils).with(100, [1, 0, 1, 0, 1, 0, 0, 1, 1])
+    cmd.run %w(write HOST %M100 1 0 1 0 1 0 0 1 1)
+  end
+
+  it 'rejects illegal values' do
+    lambda { cmd.run %w(write 1.2.3.4 %MW100 10 tust) }.should raise_exception(Clamp::UsageError)
+    lambda { cmd.run %w(write 1.2.3.4 %MW100 9999999) }.should raise_exception(Clamp::UsageError)
+  end
+
+  it 'rejects illegal addresses' do
+    lambda { cmd.run %w(write 1.2.3.4 %MW1+00 ) }.should raise_exception(Clamp::UsageError)
+  end
+
+
+  it 'should split large writes in chunks for words' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, (1..123).to_a)
+    slave.should_receive(:write_holding_registers).with(223, (124..150).to_a)
+    cmd.run %w(write HOST %MW100) + (1..150).to_a
+  end
+
+  it 'should split large writes in chunks for coils' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_multiple_coils).with(100, [0, 1] * 984)
+    slave.should_receive(:write_multiple_coils).with(2068, [0, 1] * 16)
+    cmd.run %w(write HOST %M100) + [0, 1] * 1000
+  end
+
+  it 'can write to registers as ints' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [0xffff])
+    cmd.run %w(write --int HOST %MW100 -1)
+  end
+
+  it 'can write to registers as floats' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [52429, 17095])
+    cmd.run %w(write --float HOST %MW100 99.9)
+  end
+
+  it 'can write to registers as double words' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [16959, 15])
+    cmd.run %w(write --dword HOST %MW100 999999)
+  end
+
+  it 'can write to registers as words' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [99])
+    cmd.run %w(write --word HOST %MF100 99)
+  end
+
+  it 'can write to registers using Modicon addressing' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_holding_registers).with(100, [1, 2, 3, 4])
+    cmd.run %w(write HOST 400101 1 2 3 4)
+  end
+
+  it 'can write to coils using Modicon addressing' do
+    client, slave = standard_connect_helper 'HOST'
+    slave.should_receive(:write_multiple_coils).with(100, [1, 0, 1, 0, 1, 0, 0, 1, 1])
+    cmd.run %w(write HOST 101 1 0 1 0 1 0 0 1 1)
+  end
+
+  it 'has a --slave parameter' do
+    client = mock 'client'
+    ModBus::TCPClient.should_receive(:connect).with('X').and_yield(client)
+    client.should_receive(:with_slave).with(99)
+    cmd.run %w(write --slave 99 X 101 1)
+  end
+
+end
+
+
+
+
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: modbus-cli
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tallak Tveide
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmodbus
+  requirement: &76170020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *76170020
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: &76169740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *76169740
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &76169500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *76169500
+description: Command line interface to communicate over Modbus TCP
+email:
+- tallak@tveide.net
+executables:
+- modbus
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/modbus
+- lib/modbus-cli.rb
+- lib/modbus-cli/commands_common.rb
+- lib/modbus-cli/dump_command.rb
+- lib/modbus-cli/read_command.rb
+- lib/modbus-cli/version.rb
+- lib/modbus-cli/write_command.rb
+- modbus-cli.gemspec
+- spec/dump_command_spec.rb
+- spec/modbus_cli_spec.rb
+- spec/read_command_spec.rb
+- spec/spec_helper.rb
+- spec/write_command_spec.rb
+homepage: http://www.github.com/tallakt/modbus-cli
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: modbus-cli
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Modbus command line
+test_files: []
+has_rdoc: