tallakt-plcutil 0.2.3 → 0.2.4

data/History.txt

@@ -1,3 +1,9 @@
+== 0.2.4 2012-07-13
+
+* awlpp completely rewritten based on treetop parser
+* restructuring of command line tools
+* s7tointouch currently not working at all
+
 == 0.2.2 2011-11-11
 
 * clean up for Ruby 1.9 support

data/README.rdoc

@@ -8,7 +8,8 @@ A set of command line utilities and helper classes to convert between IO list fi
 
 Currently Siemens, Schneider and Wonderware are supported, Schneider and Wonderware IAS support planned in the near future.
 
-This is still a quite rough version - pre alpha!!
+The utilities in this gem are somewhat rough quality, no guarantees are given 
+wrt correct operation. Even so, I hope they might be useful.
 
 == FEATURES/PROBLEMS:
 

data/bin/awlpp

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'tallakt-plcutil/siemens/awl_pretty_print_runner'
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'plcutil/siemens/awl_pretty_print_runner'
 
-# try: awlpp --help
-PlcUtil::AwlPrettyPrintRunner.new ARGV
+PlcUtil::AwlPrettyPrintRunner.run
 

data/bin/intouchpp

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'tallakt-plcutil/wonderware/intouch_pretty_print_runner'
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'plcutil/wonderware/intouch_pretty_print_runner'
 
 # try: intouchpp --help
 PlcUtil::IntouchPrettyPrintRunner.new ARGV

data/bin/pl7tointouch

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'tallakt-plcutil/schneider/pl7_to_intouch_runner'
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'plcutil/schneider/pl7_to_intouch_runner'
 
 # try: pl7tointouch --help
 PlcUtil::PL7ToIntouchRunner.new ARGV

data/bin/s7tointouch

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'tallakt-plcutil/siemens/step7_to_intouch_runner'
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'plcutil/siemens/step7_to_intouch_runner'
 
 # try: s7tointouch --help
 PlcUtil::Step7ToIntouchRunner.new ARGV

data/lib/{tallakt-plcutil → plcutil}/schneider/pl7_to_intouch_runner.rb

@@ -2,7 +2,7 @@
 #encoding: utf-8
 
 require 'optparse'
-require 'tallakt-plcutil/wonderware/intouchfile'
+require 'plcutil/wonderware/intouchfile'
 require 'ostruct'
 
 module PlcUtil
@@ -46,15 +46,10 @@ module PlcUtil
 
     def read_pl7_file(io)
       io.each_line do |l|
-        mres = l.match(/^%M(W|F)?(\d+)(:X(\d+))?\t(\S+)\t(\S+)(\t\"?([^\t"]*))?/)
+        mres = l.match(/^%M(W)?(\d+)(:X(\d+))?\t(\S+)\t(\S+)(\t\"?([^\t"]*))?/)
         if mres
           item = OpenStruct.new
-          case mres[1]
-          when 'W'
-            item.is_word = true
-          when 'F'
-            item.is_float = true
-          end
+          item.is_word = mres[1]
           item.index = mres[2].to_i
           item.bit_index = mres[4] && mres[4].to_i
           item.tagname = mres[5]
@@ -88,10 +83,6 @@ module PlcUtil
           @intouchfile.new_io_int(tag, data) do |io|
             io.item_name = '%d S' % (item.index + 400001)
           end
-        elsif item.is_float
-          @intouchfile.new_io_real(tag, data) do |io|
-            io.item_name = '%d F' % (item.index + 400001)
-          end
         else
           @intouchfile.new_io_disc(tag, data) do |io|
             io.item_name = (item.index + 1).to_s

data/lib/plcutil/siemens/awl/array_type.rb

@@ -0,0 +1,21 @@
+module PlcUtil
+  module Awl
+		class ArrayType
+			attr_accessor :range, :element_type
+			
+			def initialize(element_type, range)
+				@range, @element_type = range, element_type
+			end
+			
+      def skip_padding(addr)
+        addr.next_word
+      end
+
+      def end_address(start_addr)
+        start_addr.skip type.bit_size * range.count
+      end
+		end
+  end
+end
+
+

data/lib/plcutil/siemens/awl/awl.treetop

@@ -0,0 +1,172 @@
+module PlcUtil
+  module Awl
+    grammar AwlGrammar
+      rule root
+        toplevel <TopLevelNode>
+      end
+
+      rule toplevel
+        (udt <UdtNode> / db <DbNode> / ob <ObNode>)*
+      end
+
+      rule db
+        'DATA_BLOCK ' name eol
+        title
+        'VERSION : ' version eol
+        eol*
+        root_struct_decl
+        'BEGIN' eol
+        assignment*
+        'END_DATA_BLOCK' eol
+        ws_eol
+      end
+
+      rule udt
+        'TYPE ' name eol
+        'VERSION : ' version eol
+        eol*
+        root_struct_decl
+        'END_TYPE' eol
+        ws_eol
+      end
+
+      rule ob
+        'ORGANIZATION_BLOCK ' name eol
+        title
+        'VERSION : ' version eol
+        eol*
+        (!ob_end .)*
+        ob_end eol
+        ws_eol
+      end
+
+      rule name
+        quoted_string <QuotedNameNode> / db_name <DbNameNode>
+      end
+
+      rule quoted_string
+        '"' v:(!'"' .)* '"'
+      end
+
+      rule single_quoted_string
+        single_quote (!single_quote .)* single_quote
+      end
+
+      rule single_quote
+        "'"
+      end
+
+      rule db_name
+        'DB ' number:([0-9]+)
+      end
+
+      rule version
+        [0-9]+ '.' [0-9]+
+      end
+
+      rule title
+        'TITLE =' optional_title:(ws title_quoted:(quoted_string))? eol
+      end
+
+      rule ob_end
+        'END_ORGANIZATION_BLOCK'
+      end
+
+      rule assignment
+        ws identifier ws ':=' ws value ';' ws eol
+      end
+
+      rule declaration
+        ws 
+        identifier 
+        ' : ' 
+        d:(array_declaration <ArrayDeclarationNode> / nonarray_declaration <NonArrayDeclarationNode>)
+        eol
+      end
+
+      rule nonarray_declaration
+        non_array_data_type 
+        ws?
+        initial_value? ws?
+        ';' 
+        ws? comment:(line_comment?)
+      end
+
+      rule initial_value
+        ':=' ws single_quoted_string
+      end
+
+      rule array_declaration
+        'ARRAY  [' ar_begin:([0-9]+) ' .. ' ar_end:([0-9]+) ' ] OF ' 
+        array_comment:(line_comment eol ws)? non_array_data_type ws ';' ws
+      end
+
+      rule non_array_data_type
+        basic_data_type <BasicDataTypeNode> 
+        / 
+        struct_data_type <StructDataTypeNode> 
+        / 
+        udt_data_type <UdtDataTypeNode>
+      end
+
+      rule struct_data_type
+        'STRUCT' ws? eol
+        decl:declaration* 
+        ws 'END_STRUCT'
+      end
+
+      rule root_struct_decl
+        ws struct_data_type ws ';' ws? eol
+      end
+
+      rule udt_data_type
+        quoted_string
+      end
+
+      rule identifier
+        non_ws+
+      end
+
+      rule line_comment
+        '//' comment_body:(!eol .)*
+      end
+
+      rule basic_data_type
+        (
+          'INT' / 
+          'DINT' / 
+          'BOOL' / 
+          'BYTE' / 
+          'WORD' / 
+          'DWORD' / 
+          'TIME_OF_DAY' / 
+          'REAL' / 
+          'TIME' /
+          'S5TIME' /
+          'DATE' /
+          'CHAR'
+        )
+      end
+
+      rule value
+        (single_quoted_string / (!(ws / ';') .)+)
+      end
+
+      rule eol
+        "\r"? "\n"
+      end
+
+      rule ws
+        (' ' / "\t")+
+      end
+
+      rule non_ws
+        (!ws .)
+      end
+
+      rule ws_eol
+        (ws / eol)+
+      end
+    end
+  end
+end

data/lib/plcutil/siemens/awl/awl_file.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/ruby
+
+require 'polyglot'
+require 'treetop'
+require 'plcutil/siemens/awl/basic_type'
+require 'plcutil/siemens/awl/struct_type'
+require 'plcutil/siemens/awl/array_type'
+require 'plcutil/siemens/awl/treetop_nodes'
+require 'plcutil/siemens/awl/db_address'
+require 'plcutil/siemens/awl/awl.treetop'
+
+
+module PlcUtil
+  module Awl
+    class AwlFile
+      attr_reader :symlist
+
+      def initialize(filename, options = {})
+        @symlist = options[:symlist] && SymlistFile.new(options[:symlist])
+        # parse file
+        parser = PlcUtil::Awl::AwlGrammarParser.new
+        awl_nodes = parser.parse File.read(filename)
+        @awl = awl_nodes && awl_nodes.visit
+        if !@awl
+          raise [
+            "Unable to parse file: #{filename}",
+            "Failure on line #{parser.failure_line} column #{parser.failure.column}",
+            "Details:",
+            parser.failure_reason.inspect,
+          ].join("\n")
+        end
+      end
+
+      def lookup_symlist(tag)
+        (options[:blocks] && options[:blocks][tag]) || (@symlist && @symlist[tag])
+      end
+      
+      def each_exploded(options = {}, &block)
+        @awl[:dbs].each do |raw|
+          db = create_struct raw
+          name = if options[:no_block] 
+                   ''
+                 else 
+                   raw[:id]
+                 end
+
+          a = DbAddress.new 0, db_address(raw[:name])
+          db.each_exploded(a, name) do |addr, name, comment, type_name|
+            yield addr, name, comment, type_name
+          end
+        end
+      end
+      
+      def db_address(name)
+        n = @symlist[name]
+        n && n.gsub(/\s/, '')
+      end
+      private :db_address
+      
+      def get_udt(name)
+        udt = @awl[:udts].find {|u| u[:name] == name }
+        raise "Could not find UDT with name: #{name}" unless udt
+        create_struct udt
+      end
+      private :get_udt
+
+      def create_struct(raw)
+        StructType.new.tap do |s|
+          raw[:entries].each do |e|
+            base_type = case e[:data_type]
+              when Hash
+                # anonymous structure inline
+                create_struct(e[:data_type])
+              when String
+                # UDT
+                get_udt e[:data_type]
+              when Symbol
+                  BasicType::create e[:data_type]
+              end
+            if e.key? :array
+              s.add e[:id], ArrayType.new(base_type, e[:array]), e[:comment]
+            else
+              s.add e[:id], base_type, e[:comment]
+            end
+          end
+        end
+      end
+      private :create_struct
+		end
+	end
+end

data/lib/plcutil/siemens/awl/basic_type.rb

@@ -0,0 +1,52 @@
+module PlcUtil
+  module Awl
+    class BasicType
+      TYPES = {
+        :bool => 1,
+        :byte => 8,
+        :char => 8,
+        :date => 16,
+        :dint => 32,
+        :dword => 32,
+        :int => 16,
+        :real => 32,
+        :s5time => 16,
+        :time => 32,
+        :time_of_day => 32,
+        :word => 16,
+        :date_and_time => 32, # only in VAR_TEMP
+        :timer => 1,          # only in FC calls
+        :cont_c => 125 * 8
+      }
+
+      attr_accessor :bit_size, :type_name
+      
+      def initialize(bit_size, type_name)
+        @bit_size, @type_name = bit_size, type_name
+      end
+      
+      def skip_padding(addr)
+        case bit_size
+        when 1
+          addr
+        when 8
+          addr.next_byte
+        else
+          addr.next_word
+        end
+      end
+
+      def end_address(start_addr)
+        start_addr.skip bit_size
+      end
+
+      def BasicType.create(type_key)
+        b = TYPES[type_key]
+        raise "Could not find type: #{type_key.to_s}" unless b
+        BasicType.new b, type_key
+      end
+    end
+
+  end
+end
+

data/lib/plcutil/siemens/awl/db_address.rb

@@ -0,0 +1,52 @@
+module PlcUtil
+  module Awl
+		class DbAddress
+			attr_accessor :data_block_addr
+			
+			def initialize(bit_addr, data_block_addr = nil)
+				@bit_addr, @data_block_addr = bit_addr, data_block_addr
+			end
+			
+			def to_s
+				(data_block_addr || 'DB???') + ',' + byte.to_s + '.' + bit.to_s
+			end
+
+      def bit
+        @bit_addr % 8
+      end
+
+      def byte
+        @bit_addr / 8
+      end
+
+      def next_word
+        # simatic packing rules
+        # 1. 16 bit values aligned at modulo 2 address 0.0, 2.0, 4.0, 8.0, ...
+        # 2. 8 bit values aligned at each address, 0.0, 1.0, 2.0, ...
+        # 3. Structs are aligned modulo 2
+        # 4. Bools are aligned like 8 bit values, consecutive bools occupy a single byte
+
+        DbAddress.new(next_n(16), data_block_addr)
+      end
+
+      def next_byte
+        DbAddress.new(next_n(8), data_block_addr)
+      end
+
+
+      def next_n(size)
+        m = @bit_addr % size
+        if m > 0
+          (@bit_addr / size + 1) * size
+        else
+          @bit_addr
+        end
+      end
+      private :next_n
+
+      def skip(bit_count)
+        DbAddress.new @bit_addr + bit_count, data_block_addr
+      end
+		end
+  end
+end

data/lib/plcutil/siemens/awl/struct_type.rb

@@ -0,0 +1,52 @@
+module PlcUtil
+  module Awl
+		class StructType
+			def initialize
+				@children = []
+			end
+			
+			def add(name, type, comment)
+				@children << {:name => name, :type => type, :comment => comment}
+			end
+				
+      def skip_padding(addr)
+        addr.next_word
+      end
+
+      def end_address(start_addr)
+        @children.inject(start_addr) {|addr, ch| ch[:type].end_address addr }
+      end
+
+			def each_exploded(start_addr, name_prefix, &block)
+				addr = skip_padding start_addr
+        @children.each do |ch|
+          full_name = if !name_prefix || name_prefix.empty?
+                        ch[:name]
+                      else
+                        "#{name_prefix}.#{ch[:name]}"
+                      end
+          case ch[:type]
+          when StructType
+            addr = ch[:type].each_exploded(addr, full_name) do |a, n, c, t|
+              yield a, n, c, t
+            end
+          when ArrayType
+            ct = ch[:type]
+            addr = ct.skip_padding addr
+            ct.range.each do |n|
+              yield addr, "#{full_name}[#{n}]", ch[:comment], ct.element_type.type_name
+              addr = ct.element_type.end_address addr
+            end
+          when BasicType
+            ct = ch[:type]
+            addr = ct.skip_padding addr
+            yield addr, full_name, ch[:comment], ct.type_name
+            addr = ct.end_address addr
+          end
+        end
+        addr
+			end
+		end
+  end
+end
+

data/lib/plcutil/siemens/awl/symlist_file.rb

@@ -0,0 +1,28 @@
+require 'dbf'
+
+module PlcUtil
+  module Awl
+		class SymlistFile
+			def initialize(filename)
+        @symlist = {}
+        raise 'Specified symlist file not found' unless File.exists? filename
+        table = DBF::Table.new filename
+        table.each do |rec|
+          next unless rec
+          @symlist[rec.attributes['_skz']] = rec.attributes['_opiec']
+        end
+			end
+
+      def [](tag)
+        lookup tag
+      end
+
+      def lookup(tag)
+        @symlist[tag]
+      end
+		end
+  end
+end
+
+
+

data/lib/plcutil/siemens/awl/treetop_nodes.rb

@@ -0,0 +1,110 @@
+require 'treetop'
+
+module PlcUtil
+  module Awl
+    module AwlGrammar
+      module StructHelpers
+        def struct_visit_helper(struct_node)
+          struct_node.decl.elements.map do |el| 
+            { :id => el.identifier.text_value }.tap do |result|
+              el.d.visit result
+            end
+          end
+        end
+      end
+
+      module TopLevelNode
+        def visit
+          {
+            :dbs => [],
+            :udts => [],
+            :obs => []
+          }.tap do |result|
+            elements.each {|e| e.visit result }
+          end
+        end
+      end
+
+      module DbNode 
+        include StructHelpers
+        def visit(root)
+          root[:dbs] << {}.tap do |db|
+            name.hash_entry db
+            db[:entries] = struct_visit_helper root_struct_decl.struct_data_type
+          end
+        end
+      end
+
+      module UdtNode 
+        include StructHelpers
+        def visit(root)
+          root[:udts] << {}.tap do |udt|
+            name.hash_entry udt
+            udt[:entries] = struct_visit_helper root_struct_decl.struct_data_type
+          end
+        end
+      end
+
+      module ObNode
+        def visit(root)
+          root[:obs] << {}.tap do |ob|
+            ob[:title] = title.optional_title.title_quoted.v.text_value
+            name.hash_entry ob
+          end
+        end
+      end
+
+
+      module ArrayDeclarationNode
+        def visit(declaration)
+          declaration[:array] = (ar_begin.text_value.to_i)..(ar_end.text_value.to_i)
+          declaration[:comment] = array_comment.line_comment.comment_body.text_value unless array_comment.terminal?
+          non_array_data_type.visit declaration
+        end
+      end
+
+      module NonArrayDeclarationNode
+        def visit(declaration)
+          declaration[:comment] = comment.comment_body.text_value unless comment.terminal?
+          non_array_data_type.visit declaration
+        end
+      end
+
+      module BasicDataTypeNode
+        def visit(declaration)
+          declaration[:data_type] = text_value.downcase.to_sym
+        end
+      end
+
+      module StructDataTypeNode
+        include StructHelpers
+        def visit(declaration)
+            declaration[:data_type] = {}.tap do |struct|
+              struct[:entries] = struct_visit_helper self
+            end
+        end
+      end
+
+      module UdtDataTypeNode
+        def visit(declaration)
+          declaration[:data_type] = v.text_value
+        end
+      end
+
+
+
+
+      module QuotedNameNode
+        def hash_entry(h)
+          h[:name] = v.text_value
+        end
+      end
+
+      module DbNameNode
+        def hash_entry(h)
+          h[:db_number] = number.to_s.to_i
+        end
+      end
+    end
+  end
+end

data/lib/plcutil/siemens/awl_pretty_print_runner.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+
+require 'clamp'
+require 'plcutil/siemens/awl/awl_file'
+require 'plcutil/siemens/awl/symlist_file'
+
+module PlcUtil
+	# Command line tool to read and output an awl file
+	class AwlPrettyPrintRunner < Clamp::Command
+		def execute
+			opt = {
+        :symlist => symlist,
+        :blocks => Hash[block_name.split(/[,=]/)]
+      }
+			
+      file_list.each do |filename|
+        process_awl_file Awl::AwlFile.new(filename, opt)
+      end
+		end
+		
+    def fix_name(name)
+      if no_block?
+        name.sub /^[^\.]*\./, ''
+      else
+        name
+      end
+    end
+
+		def process_awl_file(awl)
+			awl.each_exploded do |addr, name, comment, type_name|
+				puts '%-11s %-40s%-10s%s' % [
+          addr.to_s,
+          fix_name(name), 
+          type_name.to_s.upcase,
+          comment
+        ]
+			end
+		end
+		
+    option %w(--no-block -n), :flag, "don't use datablock as part of the tagname"
+    option %w(--symlist -s), 'FILE', 'specify SYMLIST.DBF frfom Step 7 project'
+    option %w(--block-name -b), 'NAME=ADDR,NAME=ADDR', 'specify DB adress directly instead of using SYMLIST.DBF', :default => '' do |s|
+      raise 'Invalid format of block names, example use: A=DB20,B=DB21' unless s.match(/(\w+=\w+,)*(\w+=\w+)/)
+    end
+
+    parameter "FILE ...", 'awl files to read (exported inside Step 7)'
+	end
+end

data/lib/{tallakt-plcutil → plcutil}/siemens/step7_to_intouch_runner.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/ruby
 
 require 'optparse'
-require 'tallakt-plcutil/siemens/awlfile'
-require 'tallakt-plcutil/siemens/sdffile'
-require 'tallakt-plcutil/wonderware/intouchfile'
+require 'plcutil/siemens/awl/awl_file'
+require 'plcutil/siemens/sdffile'
+require 'plcutil/wonderware/intouchfile'
 
 module PlcUtil
 	# Command line tool to read and output an awl file

data/lib/{tallakt-plcutil → plcutil}/version.rb

@@ -1,4 +1,4 @@
 module PlcUtil
-  VERSION = '0.2.3'
+  VERSION = '0.2.2'
 end
 

data/lib/{tallakt-plcutil → plcutil}/wonderware/intouch_pretty_print_runner.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'optparse' 
-require 'tallakt-plcutil/wonderware/intouchfile'
+require 'plcutil/wonderware/intouchfile'
 
 module PlcUtil
   class IntouchPrettyPrintRunner

data/lib/{tallakt-plcutil.rb → plcutil.rb}

@@ -3,6 +3,6 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module PlcUtil
-  VERSION = '0.2.2'
+  VERSION = '0.2.4'
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tallakt-plcutil
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -13,37 +13,96 @@ date: 2010-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dbf
-  requirement: &270292080 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.6.6
+        version: '1.6'
   type: :runtime
   prerelease: false
-  version_requirements: *270292080
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: polyglot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: Ruby library for using Siemens, Schneider and Intouch files
 email: tallak@tveide.net
 executables:
 - awlpp
 - intouchpp
 - pl7tointouch
-- s7tointouch
 extensions: []
 extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files:
-- lib/tallakt-plcutil/schneider/pl7_to_intouch_runner.rb
-- lib/tallakt-plcutil/siemens/awlfile.rb
-- lib/tallakt-plcutil/siemens/awl_pretty_print_runner.rb
-- lib/tallakt-plcutil/siemens/sdffile.rb
-- lib/tallakt-plcutil/siemens/step7_to_intouch_runner.rb
-- lib/tallakt-plcutil/version.rb
-- lib/tallakt-plcutil/wonderware/intouchfile.rb
-- lib/tallakt-plcutil/wonderware/intouch_pretty_print_runner.rb
-- lib/tallakt-plcutil/wonderware/standard_sections.yaml
-- lib/tallakt-plcutil.rb
+- lib/plcutil/schneider/pl7_to_intouch_runner.rb
+- lib/plcutil/siemens/awl/array_type.rb
+- lib/plcutil/siemens/awl/awl.treetop
+- lib/plcutil/siemens/awl/awl_file.rb
+- lib/plcutil/siemens/awl/basic_type.rb
+- lib/plcutil/siemens/awl/db_address.rb
+- lib/plcutil/siemens/awl/struct_type.rb
+- lib/plcutil/siemens/awl/symlist_file.rb
+- lib/plcutil/siemens/awl/treetop_nodes.rb
+- lib/plcutil/siemens/awl_pretty_print_runner.rb
+- lib/plcutil/siemens/sdffile.rb
+- lib/plcutil/siemens/step7_to_intouch_runner.rb
+- lib/plcutil/version.rb
+- lib/plcutil/wonderware/intouchfile.rb
+- lib/plcutil/wonderware/intouch_pretty_print_runner.rb
+- lib/plcutil/wonderware/standard_sections.yaml
+- lib/plcutil.rb
 - bin/awlpp
 - bin/intouchpp
 - bin/pl7tointouch
@@ -54,7 +113,6 @@ files:
 - History.txt
 - LICENSE
 - README.rdoc
-- Rakefile
 homepage: http://github.com/tallakt/plcutil
 licenses: []
 post_install_message: 
@@ -76,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Ruby PLC file library

data/Rakefile

@@ -1,36 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "tallakt-plcutil #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/lib/tallakt-plcutil/siemens/awl_pretty_print_runner.rb

@@ -1,87 +0,0 @@
-#!/usr/bin/ruby
-
-require 'optparse'
-require 'tallakt-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
-      @no_block = false
-
-			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 fix_name(name)
-      if @no_block
-        name.sub /^[^\.]*\./, ''
-      else
-        name
-      end
-    end
-
-		def print_to_file(f)
-			@awl.each_tag do |tag| #|name, data_block_name, addr, comment, struct_comment, type|
-        require 'rubygems'
-        require 'pp'
-				f.puts @format % [
-          tag[:addr], 
-          fix_name(tag[:name]), 
-          tag[:type].to_s, 
-          [tag[:comment], tag[:struct_comment]].compact! ? '' : (@commentformat % [tag[:comment], tag[: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("-n", "--no-block", String, "Dont use the datablock as part of the tag", "name") do
-					@no_block = true
-				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/tallakt-plcutil/siemens/awlfile.rb

@@ -1,295 +0,0 @@
-#!/usr/bin/ruby
-
-
-module PlcUtil
-	# Reads a Siemens Step 7 AWL file and creates single tags with addresses and comment
-	class AwlFile
-    attr_reader :symlist
-
-		def initialize(filename, options = {})
-			@types = {}
-			init_basic_types
-			@datablocks = []
-			@symlist = {}
-			
-			if options[:symlist]
-        require 'rubygems'
-        require 'dbf' or raise 'Please install gem dbf to read symlist file'
-
-				raise 'Specified symlist file not found' unless File.exists? options[:symlist]
-				table = DBF::Table.new(options[:symlist])
-				table.each do |rec|
-          next unless 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(options = {})
-			@datablocks.each do |var|
-        name = var.name
-        if options[:no_block]
-          name = nil
-        end
-				var.type.explode(Address.new(0, data_block_address(var.name)), name, options).each do |item|
-          ii = item.clone
-          ii[:type] = item[:type].downcase.to_sym
-					yield ii
-				end
-			end
-		end
-		
-		private
-		
-		def data_block_address(name)
-			if @symlist.key? name
-				@symlist[name].gsub /\s+/, ''
-			else
-				nil
-			end
-		end
-		
-		def init_basic_types
-      types = {
-        'BOOL' => 1,
-        'BYTE' => 8,
-        'CHAR' => 8,
-        'DATE' => 2 * 8, 
-        'DINT' => 4 * 8,
-        'DWORD' => 4 * 8,
-        'INT' => 2 * 8,
-        'REAL' => 4 * 8,
-        'S5TIME' => 2 * 8,
-        'TIME' => 4 * 8,
-        'TIME_OF_DAY' => 4 * 8,
-        'WORD' => 2 * 8,
-        'DATE_AND_TIME' => 4 * 8, # ??? only used in VAR_TEMP
-        'TIMER' => 1, # Only in FC calls
-        'CONT_C' => 125 * 8, 
-      }
-      types.each {|name, size| add_type BasicType.new(name, size) }
-		end
-		
-		def add_type(type)
-				@types[type.name] = type
-		end
-
-		def lookup_type(type)
-			raise "Could not find type '#{type}'" unless @types.key? type
-			@types[type]
-		end
-		
-		def parse(file)
-			stack = []
-			in_array_decl = false # array decalrations are sometimed split on two separate lines
-      in_datablock_decl = false
-			tagname = start = stop = type = comment = nil
-      db_to_fb = {} # a list connecting a DB to the FB where it was used
-			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
-					case l
-            # TODO should also cater for 'DB  90' type addresses
-          when /^TYPE "(.+?)"/ 
-            stack = [StructType.new($1, :datatype)]
-            add_type stack.first
-          when /^FUNCTION_BLOCK "(.+?)"/
-            stack = [StructType.new($1, :functionblock)]
-            add_type stack.first
-          when /^DATA_BLOCK ("(.+?)"|DB\s+(\d+))/
-            in_datablock_decl = true
-            name = $2 || ('DB' + $3)
-            stack = [StructType.new(name, :datablock)]
-            @datablocks << Variable.new(name, stack.last)
-          when /^VAR_TEMP/
-            s = StructType.new('VAR_TEMP', :anonymous)
-            stack = [s]
-          when /^\s*(\S+) : STRUCT /
-            in_datablock_decl = false
-            s = StructType.new('STRUCT', :anonymous)
-            stack.last.add Variable.new($1, s)
-            stack << stack.last.children.last.type
-          when /^BEGIN$/
-            in_datablock_decl = false
-          when /^\s+BEGIN/
-            stack.pop
-          # New variable in struct or data block
-          when /^\s+([A-Za-z0-9_ ]+) : "?([A-Za-z0-9_ ]+?)"?\s*(:=\s*[^;]+)?;(\s*\/\/(.*))?/
-            if stack.any?
-              tagname, type_name, comment = $1, $2, ($5 || '')
-              stack.last.add Variable.new(tagname, lookup_type(type_name), comment)
-            end
-          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
-          when /^"(.*?)"$/
-            # datablock definition is stored in FB definition
-            # remember which FB to use but assign the FB
-            # only after all blocks have been loaded
-            db_to_fb[stack.first.name] = $1 if in_datablock_decl
-					end
-				end
-			end
-
-      # Update FB to DB use
-      @datablocks.each do |db|
-        if db_to_fb.key? db.name
-          fb = lookup_type db_to_fb[db.name]
-          fb.children.each {|child| db.type.add child } if fb.respond_to? :children
-        end
-      end
-		end
-		
-		def defined_type(type)
-			@types.key?(type.name)
-		end
-		
-		
-		class BasicType
-			attr_accessor :bit_size, :name
-			
-			def initialize(name, bit_size)
-				@bit_size, @name = bit_size, name
-			end
-			
-			def explode(start_addr, name, comment, struct_comment, options = {})
-        actual_start = start_addr.next_start bit_size
-        [{:addr => actual_start, :name => name, 
-          :struct_comment => struct_comment, :comment => comment, :type => @name}]
-			end
-			
-			def end_address(start_address)
-				start_address.next_start(bit_size).skip! bit_size
-			end
-		end
-
-
-		
-		class StructType
-			attr_accessor :name, :children, :type
-			
-			def initialize(name = 'STRUCT', type = :anonymous)
-				@name = name
-				@children = []
-        @type = type
-			end
-			
-			def add(child)
-				raise 'Added nil child' unless child
-				raise 'Added nil child type' unless child.type
-				@children << child
-			end
-				
-			def end_address(start_address) 
-				addr = start_address.next_start
-				@children.each do |child|
-					addr = child.type.end_address addr
-				end
-        addr.next_start!
-			end
-			
-			def explode(start_addr, name, comment = nil, struct_comment = nil, options = {})
-				addr = start_addr.next_start
-				exploded = []
-				@children.each do |child|
-
-					exploded += child.type.explode(addr, [name, child.name].compact.join('.'), child.comment, 
-                                         type == :datablock ? child.comment : struct_comment, options)
-					addr = child.type.end_address addr
-				end
-				exploded
-			end
-		end
-		
-		class ArrayType
-			attr_accessor :range, :type
-			
-			def initialize(type, range)
-				raise 'Added nil array type' unless type
-				raise 'Added nil array range' unless range
-				@range, @type = range, type
-			end
-			
-			def name
-				'ARRAY'
-			end
-
-			def end_address(start_address) 
-				addr = start_address.next_start
-				range.each do
-					addr = type.end_address addr
-				end
-				addr
-			end
-
-			def explode(start_addr, name, comment, struct_comment, options = {})
-				exploded = []
-				addr = start_addr.next_start
-				range.to_a.each_with_index do |v, i|
-					exploded += type.explode(addr, name + '[' + v.to_s + ']', comment, struct_comment, options = {})
-					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 :bit_addr, :data_block_addr
-			
-			def initialize(bit_addr, data_block_addr = nil)
-				@bit_addr, @data_block_addr = bit_addr, data_block_addr
-			end
-			
-			def to_s
-				(data_block_addr || 'DB???') + ',' + byte.to_s + '.' + bit.to_s
-			end
-
-      def bit
-        @bit_addr % 8
-      end
-
-      def byte
-        @bit_addr / 8
-      end
-
-      def next_start!(bit_size = 2 * 8)
-        bs = [bit_size, 2 * 8].min  # bools use bits, chars/bytes one byte others two byte rounding of start address
-        rest = @bit_addr % bs
-        @bit_addr += (bs - rest) if rest > 0
-        self
-      end
-
-      def next_start(bit_size = 2 * 8)
-        self.clone.next_start! bit_size
-      end
-
-      def skip!(bit_count)
-        @bit_addr += bit_count
-        self
-      end
-		end
-	end
-end