tallakt-plcutil 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-01-28
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+TODO
+bin/awlpp
+bin/s7tointouch
+lib/plcutil/siemens/awlfile.rb
+lib/plcutil/siemens/awlprettyprintrunner.rb
+lib/plcutil/siemens/step7tointouchrunner.rb
+lib/plcutil/wonderware/intouchfile.rb
+lib/plcutil/wonderware/intouchreader.rb
+lib/plcutil/wonderware/standard_sections.yaml
+lib/plcutil.rb
+script/console
+script/console.cmd
+script/destroy
+script/destroy.cmd
+script/generate
+script/generate.cmd

data/README.rdoc

@@ -0,0 +1,61 @@
+= plcutil
+
+http://github.com/tallakt/plcutil
+
+== DESCRIPTION:
+
+A set of command line utilities and helper classes to convert between IO list files of different PLC types into different HMI types.
+
+Currently Siemens and Wonderware are supported, Schneider and Wonderware IAS support planned in the near future.
+
+This is still a quite rough version - pre alpha!!
+
+== FEATURES/PROBLEMS:
+
+
+== SYNOPSIS:
+
+Print the contents of Siemens Step 7 IO file
+
+  awlpp -s SYMLIST.DBF 00000007.AWL
+
+Convert a siemens IO list into a Wonderware Intouch (non IAS) DB import file
+
+  s7tointouch -s SYMLIST.DBF -a SIEMENSPLC 00000007.AWL
+
+The commands support the --help parameter for a full list of parameters
+
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+  gem install plcutil
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 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 OR COPYRIGHT HOLDERS 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,27 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/plcutil'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('plcutil', Plcutil::VERSION) do |p|
+  p.developer('Tallak Tveide', 'tallak@tveide.net')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/TODO

@@ -0,0 +1,4 @@
+- Create gemspec
+- README describing usage
+- RDoc comments
+- RSpec tests

data/bin/awlpp

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'plcutil/siemens/awlprettyprintrunner'
+require 'plcutil/siemens/step7tointouchrunner'
+
+# try: awlpp --help
+PlcUtil::AwlPrettyPrintRunner.new ARGV
+

data/bin/s7tointouch

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'plcutil/siemens/step7tointouchrunner'
+
+# try: s7tointouch --help
+PlcUtil::Step7ToIntouchRunner.new ARGV
+

data/lib/plcutil/siemens/awlfile.rb

@@ -0,0 +1,290 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'dbf'
+
+module PlcUtil
+
+	# Reads a Siemens Step 7 AWL file and creates single tags with addresses and comment
+	class AwlFile
+		def initialize(filename, options = {})
+			@types = {}
+			init_basic_types
+			@datablocks = []
+			@symlist = {}
+			
+			if options[:symlist]
+				throw 'Specified symlist file not found' unless File.exists? options[:symlist]
+				table = DBF::Table.new(options[:symlist])
+				table.records.each do |rec|
+					@symlist[rec.attributes['_skz']] = rec.attributes['_opiec'] # or _ophist or _datatyp
+				end
+			end
+
+			@symlist.merge!(options[:blocks] || {}) # User may override blocks
+			
+			File.open filename do |f|
+				parse f
+			end
+		end
+		
+		def each_tag
+			@datablocks.each do |var|
+				var.type.explode(Address.new(0,0), var.name).each do |item|
+					yield item[:name], 
+            complete_address(var.name, item[:addr].to_s), 
+            item[:comment], 
+            item[:struct_comment], 
+            item[:type].downcase.to_sym
+				end
+			end
+		end
+		
+		private
+		
+		def data_block_address(name)
+			if @symlist.key? name
+				@symlist[name].gsub /\s+/, ''
+			else
+				nil
+			end
+		end
+		
+		def complete_address(data_block_name, address)
+			[data_block_address(data_block_name), address].select {|s| s}.join ','
+		end
+		
+		def init_basic_types
+			[BoolType.new,  BasicType.new('INT', 2), BasicType.new('REAL', 4)].each do |basic|
+				add_type basic
+			end
+		end
+		
+		def add_type(type)
+				@types[type.name] = type
+		end
+
+		def lookup_type(type)
+			throw "Could not find type '#{type}'" unless @types.key? type
+			@types[type]
+		end
+		
+		def parse(file)
+			stack = []
+			in_array_decl = false
+			tagname = start = stop = type = comment = nil
+			file.each_line do |l|
+        l.chomp!
+				if in_array_decl
+					if l.match '^\s+\"?([A-Za-z0-9_]+)"?\s?;'
+						type = $1
+						stack.last.add Variable.new(tagname, ArrayType.new(@types[type], start..stop), comment)
+					end
+					in_array_decl = false
+				else
+					in_array_decl = false
+					case l
+						when /^TYPE "([^"]+)/ 
+							stack = [StructType.new $1, :datatype]
+							add_type stack.last
+						when /^DATA_BLOCK "([^"]+)/
+							stack = [StructType.new $1, :datablock]
+							@datablocks << Variable.new($1, stack.last)
+						when /^\s*(\S+) : STRUCT /
+							s = StructType.new 'STRUCT', :anonymous
+							stack.last.add Variable.new $1, s
+							stack << stack.last.children.last.type
+						when /^\s+END_STRUCT/
+							stack.pop
+						when /^\s+([A-Za-z0-9_]+) : "?([A-Za-z0-9_]+)"?\s*(:=\s*[0-9.e+-]+)?;(\s*\/\/(.*))?/
+							# New variable in struct or data block
+							tagname, type_name, comment = $1, $2, $5
+							stack.last.add Variable.new(tagname, lookup_type(type_name), comment)
+						when /^\s+([A-Za-z0-9_]+) : ARRAY\s*\[(\d+)\D+(\d+) \] OF "?([A-Za-z0-9_]+)"?\s?;(\s*\/\/(.*))?/
+							tagname, start, stop, type, comment = $1, $2, $3, $4, $6
+							stack.last.add Variable.new(tagname, ArrayType.new(lookup_type(type), start..stop), comment)
+						when /^\s+([A-Za-z0-9_]+) : ARRAY\s*\[(\d+)\D+(\d+) \] OF(\s?\/\/(.*))?$/
+							tagname, start, stop, comment = $1, $2, $3, $4
+							in_array_decl = true
+					end
+				end
+			end
+		end
+		
+		def defined_type(type)
+			@types.key?(type.name)
+		end
+		
+		
+		class BasicType
+			attr_accessor :size, :name
+			
+			def initialize(name, size)
+				@size, @name = size, name
+			end
+			
+			def explode(start_addr, name, comment, struct_comment)
+				[:addr => start_addr.first_even_bit, :name => name, 
+          :struct_comment => struct_comment, :comment => comment, :type => @name]
+			end
+			
+			def end_address(start_address)
+				start_address.first_even_bit.skip!(size)
+			end
+		end
+
+
+		class BoolType
+			attr_accessor :name
+			
+			def initialize
+				@name = 'BOOL'
+			end
+			
+			def explode(start_addr, name, comment, struct_comment)
+				[:addr => start_addr, :name => name, 
+          :struct_comment => struct_comment, :comment => comment, :type => @name]
+			end
+			
+			def end_address(start_address)
+				start_address.next_bit
+			end
+		end
+		
+		class StructType
+			attr_accessor :name, :children, :type
+			
+			def initialize(name = 'STRUCT', type = :anonymous)
+				@name = name
+				@children = []
+        @type = type
+			end
+			
+			def add(child)
+				throw 'Added nil child' unless child
+				throw 'Added nil child type' unless child.type
+				@children << child
+			end
+				
+			def end_address(start_address) 
+				addr = start_address.first_even_bit
+				@children.each do |child|
+					addr = child.type.end_address addr
+				end
+				addr.first_bit!
+			end
+			
+			def explode(start_addr, name, comment = nil, struct_comment = nil)
+				addr = start_addr.first_even_bit
+				exploded = []
+				@children.each do |child|
+					exploded += child.type.explode(addr, name + '.' + child.name, child.comment, 
+                                         type == :datablock ? child.comment : struct_comment)
+					addr = child.type.end_address addr
+				end
+				exploded
+			end
+
+		end
+		
+		class ArrayType
+			attr_accessor :range, :type
+			
+			def initialize(type, range)
+				throw 'Added nil array type' unless type
+				throw 'Added nil array range' unless range
+				@range, @type = range, type
+			end
+			
+			def name
+				'ARRAY'
+			end
+
+			def end_address(start_address) 
+				addr = start_address
+				range.each do
+					addr = type.end_address addr
+				end
+				addr
+			end
+
+			def explode(start_addr, name, comment, struct_comment)
+				exploded = []
+				addr = start_addr
+				range.to_a.each_with_index do |v, i|
+					exploded += type.explode(addr, name + '[' + v.to_s + ']', comment, struct_comment)
+					addr = type.end_address(addr)
+				end
+				exploded
+			end
+		end
+		
+		class Variable
+			attr_accessor :name, :type, :comment
+			
+			def initialize(name, type, comment = nil)
+				@name, @type, @comment= name, type, comment
+			end
+		end
+		
+		class Address
+			attr_accessor :byte, :bit
+			
+			def initialize(byte, bit)
+				@byte, @bit = byte, bit
+			end
+			
+			def to_s
+				@byte.to_s + '.' + @bit.to_s
+			end
+			
+			def first_bit!
+				@byte += 1 if @bit > 0
+				@bit = 0
+				self
+			end
+
+			def first_bit
+				self.clone.first_bit!
+			end
+
+			def first_even_bit!
+				first_bit!
+				skip! if @byte % 2 > 0
+				self
+			end
+
+			def first_even_bit
+				self.clone.first_even_bit!
+			end
+			
+			def next
+				self.clone.next!
+			end
+			
+			def next_bit!
+				@bit += 1
+				if @bit == 8
+					@bit = 0
+					@byte += 1
+				end
+				self
+			end
+			
+			def next_bit
+				self.clone.next_bit!
+			end
+			
+			def skip!(bytes = 1)
+				(bytes * 8).times do 
+					next_bit!
+				end
+				self
+			end
+			
+			def skip(bytes = 1)
+				self.clone.skip bytes
+			end
+		end
+	end
+end

data/lib/plcutil/siemens/awlprettyprintrunner.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'plcutil/siemens/awlfile'
+
+module PlcUtil
+	# Command line tool to read and output an awl file
+	class AwlPrettyPrintRunner
+		def initialize(args)
+			@awloptions = {}
+			@format = '%-11s %-40s%-10s%s'
+			@commentformat = '# %s / %s'
+			@output = nil
+			@symlistfile = nil
+			option_parser.parse! args
+			if args.size != 1
+				show_help
+				exit
+			end
+			filename, = args
+			@awl = AwlFile.new filename, @awloptions
+			if @output
+				File.open @output, 'w' do |f|
+					print_to_file f
+				end
+			else
+				print_to_file $stdout
+			end
+		end
+		
+
+		def print_to_file(f)
+			@awl.each_tag do |name, addr, comment, struct_comment, type|
+				f.puts @format % [
+          addr, 
+          name, 
+          type.to_s, 
+          [comment, struct_comment].compact! ? '' : (@commentformat % [comment, struct_comment])
+        ]
+			end
+		end
+		
+		def option_parser
+			OptionParser.new do |opts|
+				opts.banner = "Usage: awlpp [options] AWLFILE"
+				opts.on("-c", "--csv", String, "Output as CSV file") do
+					format = '%s;%s;%s;%s' 
+					@commentformat = '%s'
+				end
+				opts.on("-s", "--symlist FILE", String, "Specify SYMLIST.DBF file from S7 project ") do |symlistfile|
+					@awloptions[:symlist] = symlistfile
+				end
+				opts.on("-b", "--block NAME=ADDR", String, "Define address of datablock without", "reading symlist") do |blockdef|
+					name, addr = blockdef.split(/=/)
+					@awloptions[:blocks] ||= {}
+					@awloptions[:blocks][name] = addr
+				end
+				opts.on("-o", "--output FILE", String, "Output to specified file instead of", "standard output") do |output|
+					@output = output
+				end
+				opts.on_tail("-h", "--help", "Show this message") do
+					puts opts
+					exit
+				end
+			end	
+		end
+		
+		def show_help
+			puts option_parser
+		end
+		
+	end
+end

data/lib/plcutil/siemens/step7tointouchrunner.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'plcutil/siemens/awlfile'
+require 'plcutil/wonderware/intouchfile'
+
+module PlcUtil
+	# Command line tool to read and output an awl file
+	class Step7ToIntouchRunner
+		def initialize(command_line_arguments)
+      # standard command line options
+			@awloptions = {}
+			@intouchoptions = {}
+			@output = nil
+			@symlistfile = nil
+      @no_block = false
+      @access_name = nil
+      @filter_file = nil
+
+      # Parse command line options
+			option_parser.parse! command_line_arguments
+			if command_line_arguments.empty?
+				show_help
+				exit
+			end
+
+      # Read Siemens S7 file
+			@awllist = command_line_arguments.map{|filename| AwlFile.new filename, @awloptions}
+
+      # create a lookup table for used tags in the file to prevent duplicate ids
+      @used_tags = {}
+      @awllist.each do |awl|
+        awl.each_tag do |tag, addr, comment, type|
+          @used_tags[siemens_to_ww_tagname_long tag] = true
+        end
+      end
+
+      # load filter file to enable override of functions filter_comment_format and filter_handle_tag
+      load @filter_file if @filter_file && File.exists?(@filter_file)
+
+      # Write to intouch file
+			if @output
+				File.open @output, 'w' do |f|
+					print_to_file f
+				end
+			else
+				print_to_file $stdout
+			end
+		end
+		
+    # This function may be overriden in filter ruby file
+    def filter_comment_format(comment, struct_comment)
+      if comment || struct_comment
+        [comment, struct_comment].compact.join(' / ').gsub(/"/, '')
+      else
+        ''
+      end
+    end
+
+    # This function may be overridden in filter ruby file
+    def filter_handle_tag(name, addr, comment, struct_comment, type, intouch_file)
+      ww_name = siemens_to_ww_tagname name
+      cc = filter_comment_format comment, struct_comment
+      case type
+        when :bool
+          intouch_file.new_io_disc(ww_name) do |io|
+            io.item_name = addr
+            io.comment = cc
+          end
+        when :int
+          intouch_file.new_io_int(ww_name) do |io|
+            io.item_name = addr
+            io.comment = cc
+          end
+        when :real
+          intouch_file.new_io_real(ww_name) do |io|
+            io.item_name = addr
+            io.comment = cc
+          end
+        else
+          throw RuntimeException.new 'Unsupported type found: ' + type.to_s
+      end
+     end
+
+
+    # This function may be overridden in filter ruby file
+    def filter_handle_awl_files
+      @awlfile.each do |awl|
+        awl.each_tag do |name, addr, comment, struct_comment, type|
+          filter_handle_tag name, addr, comment, struct_comment, type, @intouchfile
+        end
+      end
+    end
+
+
+		def print_to_file(f)
+      @intouchfile = IntouchFile.new nil, @intouchoptions
+      filter_handle_awl_files
+      i.write_csv f
+		end
+
+    def siemens_to_ww_tagname(s)
+      new_unique_tag(siemens_to_ww_tagname_long s)
+    end
+
+    def siemens_to_ww_tagname_long(s)
+      if @no_block
+        s.gsub /^[^\.]*./, ''
+      else
+        s
+      end.gsub(/\./, '_').gsub(/\[(\d+)\]/) { '_' + $1 }
+    end
+
+    def new_unique_tag_helper(s, n)
+      s[0..(31 - n.to_s.size - 1)] + '%' + n.to_s
+    end
+
+    def new_unique_tag(s)
+      if s.size < 33
+        s
+      else
+        n = nil
+        new_tag = new_unique_tag_helper s, n
+        while @used_tags.key? new_tag
+          n ||= 0
+          n += 1
+          new_tag = new_unique_tag_helper s, n
+        end
+        @used_tags[new_tag] = true
+        new_tag
+      end
+    end
+
+		def option_parser
+			OptionParser.new do |opts|
+				opts.banner = "Usage: s7tointouch [options] AWLFILE [AWLFILE ...]"
+				opts.on("-s", "--symlist FILE", String, "Specify SYMLIST.DBF file from S7 project ") do |symlistfile|
+					@awloptions[:symlist] = symlistfile
+				end
+				opts.on("-n", "--no-block", String, "Dont use the datablock as part of the tag", "name") do
+					@no_block = true
+				end
+				opts.on("-b", "--block NAME=ADDR", String, "Define address of datablock without", "reading ymlist") do |blockdef|
+					name, addr = blockdef.split(/=/)
+					@awloptions[:blocks] ||= {}
+					@awloptions[:blocks][name] = addr
+				end
+				opts.on("-a", "--access ACCESSNAME", String, "Set access name for all tags") do |access_name|
+          @intouchoptions[:access_name] = access_name
+				end
+				opts.on("-f", "--filter FILTER_RUBY_FILE", String, "Specify ruby filter file to override", "filter functions") do |filter_file|
+					@filter_file = filter_file
+				end
+				opts.on("-o", "--output FILE", String, "Output to specified file instead of", "standard output") do |output|
+					@output = output
+				end
+				opts.on_tail("-h", "--help", "Show this message") do
+					puts opts
+					exit
+				end
+			end	
+		end
+		
+		def show_help
+			puts option_parser
+		end
+	end
+end
+