LMG_modbus 1.0.2

data/LICENSE

@@ -0,0 +1,3 @@
+== LMG_modbus
+
+Put appropriate LICENSE for your project here.

data/README

@@ -0,0 +1,33 @@
+== LMG_modbus
+
+## Example - Write register test 485
+#
+#test = Modbus485.new('com1')
+#test.create_test('C:\Documents and Settings\shanksstemp\My Documents\Testing\V4Cooling2\PA\DS\LiebertDS_FDM_35_write_driver.xls')
+#puts "Running Positive Tests"
+#test.run_modbus_write(WRITE_POSITIVE,RESULT_POSITIVE)
+#puts "Running Negative Tests"
+#test.run_modbus_write(WRITE_NEGATIVE,RESULT_NEGATIVE)
+#puts "Restoring Default"
+#test.run_modbus_write(WRITE_DEFAULT,RESULT_DEFAULT) #default
+#test.close
+
+# Example - Write register test TCP
+#
+#test = ModbusTCP.new('126.4.202.199')
+#test.create_test('C:\Documents and Settings\shanksstemp\Desktop\PA\DS\LiebertDS_FDM_35_writedriver.xls')
+#test.run_modbus_write('g','k')
+#test.close
+
+# Example - Static Test using modpoll
+
+#test = ModbusPoller485.new(1, 'com1','C:\Documents and Settings\shanksstemp\Desktop\XP\XDC\XDC_FDM_207.xls','c:\win32')
+#test.run
+
+#Example - Read time and set time
+#test = Modbus485.new('com1')
+#test.read_time_register(9998)
+
+#test.write_time_register(9998,Time.now)
+#sleep(60)
+#test.read_time_register(9998)

data/Rakefile

@@ -0,0 +1,45 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'LMG_modbus'
+  s.version = '1.0.2'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Useful set of test automation classes for bulk polling and bulk writing modbus registers'
+  s.description = s.summary
+  s.author = ''
+  s.email = ''
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "LMG_modbus Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/LMG_modbus.rb

@@ -0,0 +1,329 @@
+# Required for OLE automation with Microsoft Excel
+require 'win32ole'
+require 'rmodbus'
+
+# Generic Test Class
+module Test
+
+  puts "Test started..."
+
+  #Constants that define important columns in the spreadsheet
+
+  REGISTER = 'b'
+  RESULT_POS1 = 'k'
+  RESULT_POS2 = 'l'
+  RESULT_POS3 = 'm'
+  RESULT_POS4 = 'n'
+  WRITE_VAL_POS1 = 'g'
+  WRITE_VAL_POS2 = 'h'
+  WRITE_VAL_POS3 = 'i'
+  WRITE_VAL_POS4 = 'j'
+  XLUP = '-4162'
+
+  #Every Test requires a spreadsheet that contains the data that drives the test.
+  #path_to_base_ss is the file location of such a spreadsheet
+  
+  def create_test(path_to_base_ss)
+    @base_ss = path_to_base_ss
+    @new_ss = (@base_ss.chomp(".xls")<<'_'<<Time.now.to_a.reverse[5..9].to_s<<(".xls")).gsub('driver','result')
+    @start_time = Time.now
+    @end_time = ''
+    @ss = WIN32OLE::new('excel.Application')
+    @wb = @ss.Workbooks.Open(@base_ss)
+    @wb.SaveAs(@new_ss)
+    @ws = @wb.Worksheets(1)
+  end
+  def run_modbus_write(read_column, write_column)
+    @start_time = Time.now
+    @total_rows = @ws.Range("A65536").End(XLUP).Row
+    @row = 2
+    while (@row <= @total_rows)
+      @inner_row = @row
+      register_value = process_test_case(@ws.Range("#{REGISTER}#{@row}")['Value'],@ws.Range("#{read_column}#{@row}")['Value'] )
+      register_value.each do |s|
+        @ws.Range("#{write_column}#{@inner_row}")['Value'] = s
+        @inner_row += 1
+      end unless register_value.is_a?(NilClass)
+      @ws.Range("#{write_column}#{@inner_row}")['Value'] = $! if register_value == nil
+      @row += 1
+      @wb.Save
+    end
+    @wb.Save
+    @fin = Time.now
+    p @fin
+    @elapsed = (@fin - @start_time)
+    puts " Elapsed time is seconds is: #{@elapsed}"
+  end
+  def open_result
+    @ss.Visible = true
+    @ss.Workbooks.Open(@new_ss)
+    gets
+  end
+  def close
+    @wb.Close
+  end
+  
+end
+
+# This module subtracts 1 from each register address as rmodbus is 1 index based and Liebert is 0 index based.
+module LMG_Modbus_Client
+
+  def read_coils(addr, ncoils)
+    super(addr-1,ncoils)
+  end
+  def read_discrete_inputs(addr, ncoils)
+    super(addr-1,ncoils)
+  end
+  def read_holding_registers(addr, nreg)
+    super(addr-1,nreg)
+  end
+  def read_input_registers(addr, nreg)
+    begin
+    super(addr-1,nreg)
+    rescue Exception => e
+      e.message
+    end
+  end
+  def write_single_coil(addr, val,delay=1)
+    super(addr-1,val)
+    sleep(delay)
+  end
+  def write_single_register(addr, val, delay=1)
+    begin
+    super(addr-1,val)
+    sleep(delay)
+    rescue Exception => e
+      e.message
+    end
+  end
+  def write_multiple_coils(addr, val, delay=1)
+    super(addr-1,val)
+    sleep(delay)
+  end
+  def write_multiple_registers(addr, val, delay=1)
+    super(addr-1,val)
+    sleep(delay)
+  end
+  def process_test_case(addr,val)
+    register_array = register_type(addr)
+    print "Writing value #{val.to_i} to register #{register_array[0]}..."
+    result = write_single_register(register_array[0].to_i,val.to_i,2)
+    if result.is_a?(Integer) == FALSE then
+      puts "An error occured"
+      return result
+    end
+    result = read_input_registers(register_array[0].to_i,register_array[2].to_i)
+    puts " result of read is #{result}"
+    return result
+  end
+  def read_time_register(addr)
+  epoch = ''
+  self.read_input_registers(addr,2).each do |reg|
+        val = reg.to_i.to_s(2)
+        while val.size < 16
+          val = val.insert(0,'0')
+        end
+        epoch << val
+    end
+  puts Time.at(epoch.to_i(2))
+end
+  def write_time_register(addr,val) 
+    time = val.to_i.to_s(2)
+    string_array = time.split(//) #Convert to an array
+    while string_array.size < 32
+      string_array.unshift(0) ##Pad with leading 0's to make 32 bit
+    end 
+    write_multiple_registers(addr, Array[string_array[0..15].join.to_i(2), string_array[16..31].join.to_i(2)])
+  end
+
+end
+
+# "Virtual" class that implements most of the nasty stuff
+module ModbusPoller
+  #Excel constant for the UP arrow - from http://techsupt.winbatch.com/ts/T000001033005F9.html
+  XLUP = -4162
+  include Test
+  private
+  def prepare_test(path_to_base_ss,path_to_modpoll)
+    create_test(path_to_base_ss)
+    @modpoll_workingdir = path_to_modpoll
+
+    # Point to local modpoll dir
+    Dir.chdir(@modpoll_workingdir) # Change working dir to modpoll.exe location
+    print "The working directory for modpoll is: "
+    p Dir.pwd
+  end
+  def run
+    @start_time = Time.now
+    @total_rows = @ws.Range("A65536").End(XLUP).Row
+    @row = 2
+    while (@row <= @total_rows)
+      @inner_row = @row
+      register_value = query_modbus(@ws.Range("b#{@row}")['Value'])
+      if @bit_position != nil then
+        if register_value.to_i == 0 then
+          @ws.Range("g#{@inner_row}")['Value'] = 0
+        else
+        s = "%.16b" % register_value.to_i.abs.to_s(2)
+        @ws.Range("g#{@inner_row}")['Value'] = s[s.size-1-@bit_position.to_i].chr
+        end
+        @inner_row += 1
+      else
+      register_value.split.each do |s|
+        @ws.Range("g#{@inner_row}")['Value'] = s
+        @inner_row += 1
+      end
+      end
+      @row += 1
+      @wb.Save
+    end
+    @wb.Save
+    @wb.Close
+    @fin = Time.now
+    p @fin
+    @elapsed = (@fin - @start_time)
+    puts " Elapsed time is seconds is: #{@elapsed}"
+  end
+  def query_modbus(register)
+    count = 1
+    bit_count = 0
+    starting_register_and_type = register_type(register)
+    starting_register = starting_register_and_type[0]
+
+    #Determine the appropriate count of registers to query.
+    while (@row <= @total_rows)
+
+      current_register_and_type = register_type(@ws.Range("b#{@row}")['Value'])
+      current_register = current_register_and_type[0]
+      type = current_register_and_type[1]
+      current_register_size = current_register_and_type[2]
+      @bit_position = current_register_and_type[3]
+
+      if @row < @total_rows
+        next_register_and_type = register_type(@ws.Range("b#{@row+1}")['Value'])
+        next_register = next_register_and_type[0]
+        next_register_size = next_register_and_type[2]
+        next_bit_position = next_register_and_type[3]
+      end
+
+      if @bit_position == nil and next_bit_position == nil then
+        if(current_register_size == next_register_size and
+              next_register.to_i == current_register.to_i + current_register_size.to_i and
+              count < 99) then
+          count += 1
+          @row += 1
+        else break
+        end
+      else break
+      end
+    end
+
+    #Build and pass the commands to the OS
+    if (@row <= @total_rows) then
+      begin
+    command = @base_cmd + count.to_s + ' -a ' + @slave_addr.to_s + type + ' -r ' + starting_register + ' ' + @target
+      rescue TypeError
+        puts 'An error occured, is the driver spreadsheet in the proper format?'
+        return 'Error!'
+      end
+    puts"command = #{command}"
+    modbus_values =''
+    modbus_data = `#{command}`.each do |s|
+      if s =~ /^\[/ #If stdout line starts with a '['
+        array = s.split(/ /)
+        modbus_values << array[1]
+      end
+    end
+    return modbus_values
+    end
+  end
+  def register_type(register)
+    #Determine the type of register.
+
+    type = case register
+    when /^3.*1\)$/ then ' -t 3' #16 bit input register
+    when /^3.*2\)$/ then ' -t 3:int -i' #32 bit input register - Date/Time fields need the -i switch (Big Endian)
+    when /^3.*20\)$/ then ' -t 3' #16 bit input register
+    when /^4.*1\)$/ then ' -t 4' #16 bit holding register
+    when /^4.*2\)$/ then ' -t 4:int -i' #32 bit holding register - Date/Time fields need the -i switch (Big Endian)
+    when /^4.*1\).*Bit.*/ then type = ' -t 4'
+    when /^1/ then ' -t 1' #Discrete input register
+    end
+
+    type = ' -t 0' if register.length() < 8
+    #Cleanup the register value
+
+    register_size = register.slice(/\(.*\)/) #Match the parenthetical portion of the string (size)
+    bit_position = register.slice(/ - Bit.*$/)  #Match the Bit specification
+    register_value = register.gsub(/\(.*\)/,'') #Remove the parenthetical portion of the string
+    register_value = register_value.gsub(/^./,'') unless type == ' -t 0' #Remove the first character
+    register_value = register_value.gsub(/^0+/,'') #Remove any leading zeros
+    register_value = register_value.gsub(/ - Bit.*/,'') #Remove the - Bit specification
+
+    #Build an array of register number type and size
+
+    return_value = Array.new
+    bit_position = bit_position.gsub(' - Bit ','') unless bit_position == nil
+    return_value[0,3] = [register_value, type, register_size.tr('()',''),bit_position]
+ end
+
+end
+
+# Class to poll modbus TCP interfaces
+class ModbusPollerTCP
+  include ModbusPoller
+  # slave_addr:: the address of the modpoll server.
+  # ip:: the ip address of the modpoll server.
+  # path_to_base_ss:: the spreadsheet that contains the modbus datapoints to poll.
+  # path_to_modpoll:: the path to the modpoll executable.
+  # encapsulation:: whether or not to use encapsulated RTU over TCP
+  def initialize(slave_addr, ip,path_to_base_ss,path_to_modpoll,encapsulation)
+
+    prepare_test(path_to_base_ss,path_to_modpoll)
+    case encapsulation
+    when 'enc' then @base_cmd = 'modpoll -o 5.0 -p 8002 -1 -m enc -c '
+    else @base_cmd = 'modpoll -o 5.0 -1 -m tcp -c ' #TODO This should get more specific or use an optional argument
+    end
+
+    @slave_addr = slave_addr
+    @target = ip
+  end
+  # Call run to begin the test
+  def run
+    super
+  end
+end
+
+# Class to poll modbus 485 interfaces
+class ModbusPoller485
+  include ModbusPoller
+  # slave_addr:: the address of the modpoll server.
+  # com_port:: the serial interface attached to the modpoll server (e.g. com1, com2, com3...).
+  # path_to_base_ss:: the spreadsheet that contains the modbus datapoints to poll.
+  # path_to_modpoll:: the path to the modpoll executable.
+  def initialize(slave_addr, com_port,path_to_base_ss,path_to_modpoll)
+    prepare_test(path_to_base_ss,path_to_modpoll)
+    @base_cmd = 'modpoll -o 5.0 -1 -p none -c '
+    @slave_addr = slave_addr
+    @target = com_port
+  end
+  # Call run to begin the test
+  def run
+    super
+  end
+end
+
+# Class to work with Modbus485 (RTU)
+class Modbus485 < ModBus::RTUClient
+  include LMG_Modbus_Client
+  include Test
+  include ModbusPoller
+end
+
+# Class to work with ModbusTCP
+class ModbusTCP < ModBus::TCPClient
+  include LMG_Modbus_Client
+  include Test
+  include ModbusPoller
+end
+

data/lib/example.rb

@@ -0,0 +1,48 @@
+require 'LMG_modbus'
+
+# Constant for the number of seconds in a year from http://en.wikipedia.org/wiki/Year
+YEAR = 31557600
+DAY = 86400
+
+# Constants for columns in the test driver spreadsheet
+WRITE_DEFAULT = 'G'
+WRITE_POSITIVE = 'H'
+WRITE_NEGATIVE = 'I'
+RESULT_DEFAULT = 'K'
+RESULT_POSITIVE = 'L'
+RESULT_NEGATIVE = 'M'
+
+## Example - Write register test 485
+
+#test = Modbus485.new('com1')
+#test.create_test('C:\Documents and Settings\shanksstemp\My Documents\Testing\V4Cooling2\CR\CRV_FDM_462_write_driver.xls')
+#puts "Running Positive Tests"
+#test.run_modbus_write(WRITE_POSITIVE,RESULT_POSITIVE)
+#puts "Running Negative Tests"
+#test.run_modbus_write(WRITE_NEGATIVE,RESULT_NEGATIVE)
+#puts "Restoring Default"
+#test.run_modbus_write(WRITE_DEFAULT,RESULT_DEFAULT) #default
+#test.close
+
+# Example - Write register test TCP
+#
+#test = ModbusTCP.new('126.4.202.199')
+#test.create_test('C:\Documents and Settings\shanksstemp\Desktop\PA\DS\LiebertDS_FDM_35_writedriver.xls')
+#test.run_modbus_write('g','k')
+#test.close
+
+# Example - Static Test using modpoll
+
+#test = ModbusPoller485.new(1, 'com1','C:\Documents and Settings\shanksstemp\My Documents\Testing\V4Cooling2\CR\CRV_FDM_462.xls','c:\win32')
+#test.run
+
+#Example - Read time and set time
+test = Modbus485.new('com1')
+#test.read_time_register(258)
+#test.read_time_register(260)
+#test.read_time_register(265)
+test.read_time_register(9998)
+
+test.write_time_register(9998,Time.now-30*YEAR)
+sleep(60)
+test.read_time_register(9998)

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: LMG_modbus
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 2
+  version: 1.0.2
+platform: ruby
+authors: 
+- ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-02 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Useful set of test automation classes for bulk polling and bulk writing modbus registers
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/example.rb
+- lib/LMG_modbus.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Useful set of test automation classes for bulk polling and bulk writing modbus registers
+test_files: []
+