origen 0.0.1 → 0.0.2

data/lib/origen/tester/j750/generator/flow_line.rb

@@ -0,0 +1,288 @@
+module Origen
+  module Tester
+    class J750
+      module Generator
+        class FlowLine
+          attr_accessor :type, :id, :cz_setup # cz_setup is a virtual attrib since it is not part of the regular flow line
+          # cz_setup combine with instance name when characterize opcode is used
+
+          # Attributes for each flow line, these must be declared in the order they are to be output
+          ATTRS = %w(label enable job part env opcode parameter tname tnum bin_pass bin_fail
+                     sort_pass sort_fail result flag_pass flag_fail state
+                     group_specifier group_sense group_condition group_name
+                     device_sense device_condition device_name
+                     debug_assume debug_sites comment
+                  )
+
+          # Map any aliases to the official names here, multiple aliases for a given attribute
+          # are allowed
+          ALIASES = {
+            bin:            :bin_fail,
+            softbin:        :sort_fail,
+            soft_bin:       :sort_fail,
+            name:           :tname,
+            number:         :tnum,
+            if_enable:      :enable,
+            if_enabled:     :enable,
+            enabled:        :enable,
+            # Aliases can also be used to set defaults on multiple attributes like this,
+            # use :value to refer to the value passed in to the given alias
+            flag_false:     { device_condition: 'flag-false',
+                              device_name:      :value
+                           },
+            flag_true:      { device_condition: 'flag-true',
+                              device_name:      :value
+                           },
+            flag_false_any: { group_specifier: 'any-active',
+                              group_condition: 'flag-false',
+                              group_name:      :value
+                               },
+            flag_false_all: { group_specifier: 'all-active',
+                              group_condition: 'flag-false',
+                              group_name:      :value
+                               },
+            flag_true_any:  { group_specifier: 'any-active',
+                              group_condition: 'flag-true',
+                              group_name:      :value
+                              },
+            flag_true_all:  { group_specifier: 'all-active',
+                              group_condition: 'flag-true',
+                              group_name:      :value
+                              },
+            flag_clear:     { device_condition: 'flag-clear',
+                              device_name:      :value
+                           }
+          }
+
+          # Assign attribute defaults here, generally this should match whatever defaults
+          # Teradyne has set whenever you create a new test instance, etc.
+          DEFAULTS = {
+            test:              {
+              opcode: 'Test',
+              result: 'Fail'
+            },
+            cz:                {
+              opcode: 'characterize',
+              result: 'None'
+            },
+            goto:              {
+              opcode: 'goto'
+            },
+            nop:               {
+              opcode: 'nop'
+            },
+            set_device:        {
+              opcode: 'set-device'
+            },
+            set_error_bin:     {
+              opcode: 'set-error-bin'
+            },
+            enable_flow_word:  {
+              opcode: 'enable-flow-word'
+            },
+            disable_flow_word: {
+              opcode: 'disable-flow-word'
+            },
+            logprint:          {
+              opcode: 'logprint'
+            }
+          }
+
+          # Generate accessors for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_accessor attr.to_sym
+          end
+
+          ALIASES.each do |_alias, val|
+            if val.is_a? Hash
+              define_method("#{_alias}=") do |v|
+                val.each do |k, _v|
+                  myval = _v == :value ? v : _v
+                  send("#{k}=", myval)
+                end
+              end
+            else
+              define_method("#{_alias}=") do |v|
+                send("#{val}=", v)
+              end
+              define_method("#{_alias}") do
+                send(val)
+              end
+            end
+          end
+
+          def initialize(type, attrs = {})
+            @ignore_missing_instance = attrs.delete(:instance_not_available)
+            self.cz_setup = attrs.delete(:cz_setup)
+            @type = type
+            # Set the defaults
+            DEFAULTS[@type.to_sym].each do |k, v|
+              send("#{k}=", v) if self.respond_to?("#{k}=")
+            end
+            # Then the values that have been supplied
+            attrs.each do |k, v|
+              send("#{k}=", v) if self.respond_to?("#{k}=")
+            end
+          end
+
+          def parameter=(value)
+            if (@type == :test || @test == :cz) && !@ignore_missing_instance
+              if value.is_a?(String) || value.is_a?(Symbol)
+                fail "You must supply the actual test instance object for #{value} when adding it to the flow"
+              end
+            end
+            @parameter = value
+          end
+
+          def parameter
+            # When referring to the test instance take the opportunity to refresh the current
+            # version of the test instance
+            @parameter = Origen.interface.identity_map.current_version_of(@parameter)
+          end
+
+          # Returns the fully formatted flow line for insertion into a flow sheet
+          def to_s
+            l = "\t"
+            ATTRS.each do |attr|
+              if attr == 'parameter'
+                ins = parameter
+                if ins.respond_to?(:name)
+                  l += "#{ins.name}"
+                else
+                  l += "#{ins}"
+                end
+                if cz_setup
+                  l += " #{cz_setup}\t"
+                else
+                  l += "\t"
+                end
+              else
+                l += "#{send(attr)}\t"
+              end
+            end
+            "#{l}"
+          end
+
+          def job
+            if !if_jobs.empty? && !unless_jobs.empty?
+              fail "Both if and unless jobs have been defined for test: #{parameter}"
+            elsif !if_jobs.empty?
+              if_jobs.join(',')
+            elsif !unless_jobs.empty?
+              unless_jobs.map { |j| "!#{j}" }.join(',')
+            else
+              ''
+            end
+          end
+          alias_method :jobs, :job
+
+          def unless_enable=(*_args)
+          end
+          alias_method :unless_enabled=, :unless_enable=
+
+          def if_jobs
+            @if_jobs ||= []
+          end
+
+          def unless_jobs
+            @unless_jobs ||= []
+          end
+
+          def if_job=(jobs)
+            [jobs].flatten.compact.each do |job|
+              job = job.to_s.upcase
+              if job =~ /!/
+                self.unless_job = job
+              else
+                if_jobs << job unless if_jobs.include?(job)
+              end
+            end
+          end
+          alias_method :if_jobs=, :if_job=
+          alias_method :add_if_jobs, :if_job=
+          alias_method :add_if_job, :if_job=
+
+          def unless_job=(jobs)
+            [jobs].flatten.compact.each do |job|
+              job = job.to_s.upcase
+              job.gsub!('!', '')
+              unless_jobs << job unless unless_jobs.include?(job)
+            end
+          end
+          alias_method :unless_jobs=, :unless_job=
+          alias_method :add_unless_jobs, :unless_job=
+          alias_method :add_unless_job, :unless_job=
+
+          def continue_on_fail
+            self.result = 'None'
+          end
+
+          def continue_pass
+            self.result = 'Pass'
+          end
+
+          def debug_assume_pass
+            self.debug_assume = 'Pass'
+          end
+
+          def debug_assume_fail
+            self.debug_assume = 'Fail'
+          end
+
+          #          def debug_sites
+          #            self.debug_sites = "All"
+          #          end
+
+          def set_flag_on_fail
+            self.flag_fail = "#{id}_FAILED"
+          end
+
+          def set_flag_on_pass
+            self.flag_pass = "#{id}_PASSED"
+          end
+
+          def set_flag_on_ran
+            self.flag_pass = "#{id}_RAN"
+          end
+
+          def run_if_any_passed(parent)
+            parent.continue_on_fail
+            self.flag_true_any = parent.set_flag_on_pass
+          end
+
+          def run_if_all_passed(parent)
+            parent.continue_on_fail
+            self.flag_true_all = parent.set_flag_on_pass
+          end
+
+          def run_if_any_failed(parent)
+            parent.continue_on_fail
+            self.flag_true_any = parent.set_flag_on_fail
+          end
+
+          def run_if_all_failed(parent)
+            parent.continue_on_fail
+            self.flag_true_all = parent.set_flag_on_fail
+          end
+
+          def id
+            @id || "#{parameter}_#{unique_counter}"
+          end
+
+          def unique_counter
+            @unique_counter ||= self.class.unique_counter
+          end
+
+          def self.unique_counter
+            @ix ||= -1
+            @ix += 1
+          end
+
+          def test?
+            @type == :test
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/generator/patgroup.rb

@@ -0,0 +1,111 @@
+module Origen
+  module Tester
+    class J750
+      module Generator
+        class Patgroup
+          attr_accessor :index
+
+          class Pattern
+            ATTRS = %w(group_name pattern_file comment)
+
+            ALIASES = {
+              pattern: :pattern_file
+            }
+
+            DEFAULTS = {
+            }
+
+            # Generate accessors for all attributes and their aliases
+            ATTRS.each do |attr|
+              attr_accessor attr.to_sym
+            end
+
+            ALIASES.each do |_alias, val|
+              define_method("#{_alias}=") do |v|
+                send("#{val}=", v)
+              end
+              define_method("#{_alias}") do
+                send(val)
+              end
+            end
+
+            def initialize(patgroup, attrs = {})
+              # Set the defaults
+              DEFAULTS.each do |k, v|
+                send("#{k}=", v)
+              end
+              # Then the values that have been supplied
+              self.group_name = patgroup
+              attrs.each do |k, v|
+                send("#{k}=", v)
+              end
+            end
+
+            def to_s
+              l = "\t"
+              ATTRS.each do |attr|
+                l += "#{send(attr)}\t"
+              end
+              "#{l}"
+            end
+          end
+
+          # Specify multiple patterns by passing an array of attributes
+          # as the 2nd argument:
+          #
+          #   Patset.new("mrd1_pgrp", :pattern => "nvm_mrd1.PAT")
+          #
+          #   Patset.new("mrd1_pgrp", [{:pattern => "nvm_mrd1.PAT"},
+          #                            {:pattern => "nvm_global_subs.PAT},
+          #                           ])
+          def initialize(name, attrs = {})
+            attrs = [attrs] unless attrs.is_a? Array
+            attrs.each do |pattrs|
+              if pattrs[:pattern]
+                pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
+                Origen.interface.referenced_patterns << pat
+              end
+              lines << Pattern.new(name, pattrs)
+            end
+            self.name = name
+          end
+
+          def ==(other_patgroup)
+            self.class == other_patgroup.class &&
+              name.to_s == other_patgroup.name.to_s &&
+              sorted_pattern_files == other_patgroup.sorted_pattern_files
+          end
+
+          def name
+            @name
+          end
+
+          def name=(n)
+            @name = n
+            lines.each { |l| l.group_name = n }
+            n
+          end
+
+          # Returns all lines in the pattern set
+          def lines
+            @lines ||= []
+          end
+
+          # Returns all pattern files in the pattern set in alphabetical order
+          def sorted_pattern_files
+            @lines.map(&:file_name).sort
+          end
+
+          # Returns the fully formatted pattern group for insertion into a patgroups sheet
+          def to_s
+            l = ''
+            lines.each do |line|
+              l += "#{line}\r\n"
+            end
+            l.chomp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/generator/patgroups.rb

@@ -0,0 +1,41 @@
+module Origen
+  module Tester
+    class J750
+      module Generator
+        class Patgroups
+          include Origen::Tester::Generator
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/j750/generator/templates/patgroups.txt.erb"
+          OUTPUT_POSTFIX = 'patgroups'
+
+          def add(name, options = {})
+            p = Patgroup.new(name, options)
+            collection << p
+            p
+          end
+
+          def finalize(_options = {})
+            uniq!
+            sort!
+          end
+
+          # Present the patgroups in the final sheet in alphabetical order
+          def sort!
+            collection.sort_by!(&:name)
+          end
+
+          # Removes all duplicate patgroups
+          def uniq!
+            uniques = []
+            collection.each do |patgroup|
+              unless uniques.any? { |p| p == patgroup }
+                uniques << patgroup
+              end
+            end
+            self.collection = uniques
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/generator/patset.rb

@@ -0,0 +1,111 @@
+module Origen
+  module Tester
+    class J750
+      module Generator
+        class Patset
+          attr_accessor :index
+
+          class Pattern
+            ATTRS = %w(pattern_set file_name start_label stop_label comment)
+
+            ALIASES = {
+              pattern: :file_name
+            }
+
+            DEFAULTS = {
+            }
+
+            # Generate accessors for all attributes and their aliases
+            ATTRS.each do |attr|
+              attr_accessor attr.to_sym
+            end
+
+            ALIASES.each do |_alias, val|
+              define_method("#{_alias}=") do |v|
+                send("#{val}=", v)
+              end
+              define_method("#{_alias}") do
+                send(val)
+              end
+            end
+
+            def initialize(patset, attrs = {})
+              # Set the defaults
+              DEFAULTS.each do |k, v|
+                send("#{k}=", v)
+              end
+              # Then the values that have been supplied
+              self.pattern_set = patset
+              attrs.each do |k, v|
+                send("#{k}=", v)
+              end
+            end
+
+            def to_s
+              l = "\t"
+              ATTRS.each do |attr|
+                l += "#{send(attr)}\t"
+              end
+              "#{l}"
+            end
+          end
+
+          # Specify multiple patterns by passing an array of attributes
+          # as the 2nd argument:
+          #
+          #   Patset.new("mrd1_pset", :pattern => "nvm_mrd1.PAT")
+          #
+          #   Patset.new("mrd1_pset", [{:pattern => "nvm_mrd1.PAT"},
+          #                            {:pattern => "nvm_global_subs.PAT, :start_label => "subr"}
+          #                           ])
+          def initialize(name, attrs = {})
+            attrs = [attrs] unless attrs.is_a? Array
+            attrs.each do |pattrs|
+              if pattrs[:pattern]
+                pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
+                Origen.interface.referenced_patterns << pat
+              end
+              lines << Pattern.new(name, pattrs)
+            end
+            self.name = name
+          end
+
+          def ==(other_patset)
+            self.class == other_patset.class &&
+              name.to_s == other_patset.name.to_s &&
+              sorted_pattern_files == other_patset.sorted_pattern_files
+          end
+
+          def name
+            @name
+          end
+
+          def name=(n)
+            @name = n
+            lines.each { |l| l.pattern_set = n }
+            n
+          end
+
+          # Returns all lines in the pattern set
+          def lines
+            @lines ||= []
+          end
+
+          # Returns all pattern files in the pattern set in alphabetical order
+          def sorted_pattern_files
+            @lines.map(&:file_name).sort
+          end
+
+          # Returns the fully formatted pattern set for insertion into a patset sheet
+          def to_s
+            l = ''
+            lines.each do |line|
+              l += "#{line}\r\n"
+            end
+            l.chomp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/generator/patsets.rb

@@ -0,0 +1,41 @@
+module Origen
+  module Tester
+    class J750
+      module Generator
+        class Patsets
+          include Origen::Tester::Generator
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/j750/generator/templates/patsets.txt.erb"
+          OUTPUT_POSTFIX = 'patsets'
+
+          def add(name, options = {})
+            p = Patset.new(name, options)
+            collection << p
+            p
+          end
+
+          def finalize(_options = {})
+            uniq!
+            sort!
+          end
+
+          # Present the patsets in the final sheet in alphabetical order
+          def sort!
+            collection.sort_by!(&:name)
+          end
+
+          # Removes all duplicate patsets
+          def uniq!
+            uniques = []
+            collection.each do |patset|
+              unless uniques.any? { |p| p == patset }
+                uniques << patset
+              end
+            end
+            self.collection = uniques
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/j750/generator/templates/flow.txt.erb

@@ -0,0 +1,9 @@
+% unless @append
+DFF 1.1	Flow Table																											
+																												
+			Gate			Command				Bin Number		Sort Number			Flag			Group				Device			Debug			
+	Label	Enable	Job	Part	Env	Opcode	Parameter	TName	TNum	Pass	Fail	Pass	Fail	Result	Pass	Fail	State	Specifier	Sense	Condition	Name	Sense	Condition	Name	Assume	Sites	Comment	
+% end    
+% collection.each do |test|
+<%= test %>
+% end    

data/lib/origen/tester/j750/generator/templates/instances.txt.erb

@@ -0,0 +1,16 @@
+% unless @append
+DFF 1.3	Test Instances																																																																																													
+																																																																																														
+		Test Procedure			DC Specs		AC Specs		Sheet Parameters				Other Parameters																																																																																	
+	Test Name	Type	Name	Called As	Category	Selector	Category	Selector	Time Sets	Edge Sets	Pin Levels	Overlay	Arg0	Arg1	Arg2	Arg3	Arg4	Arg5	Arg6	Arg7	Arg8	Arg9	Arg10	Arg11	Arg12	Arg13	Arg14	Arg15	Arg16	Arg17	Arg18	Arg19	Arg20	Arg21	Arg22	Arg23	Arg24	Arg25	Arg26	Arg27	Arg28	Arg29	Arg30	Arg31	Arg32	Arg33	Arg34	Arg35	Arg36	Arg37	Arg38	Arg39	Arg40	Arg41	Arg42	Arg43	Arg44	Arg45	Arg46	Arg47	Arg48	Arg49	Arg50	Arg51	Arg52	Arg53	Arg54	Arg55	Arg56	Arg57	Arg58	Arg59	Arg60	Arg61	Arg62	Arg63	Arg64	Arg65	Arg66	Arg67	Arg68	Arg69	Arg70	Arg71	Arg72	Arg73	Arg74	Arg75	Arg76	Arg77	Arg78	Arg79	Comment	
+% end    
+% collection.each do |test_instance|
+%   if test_instance.respond_to?("each")
+%# Instance group case...
+%     test_instance.each do |ins|
+<%= ins.to_s(test_instance.name) %>
+%     end    
+%   else
+<%= test_instance %>
+%   end    
+% end    

data/lib/origen/tester/j750/generator/templates/patgroups.txt.erb

@@ -0,0 +1,8 @@
+% unless @append
+DFF 1.0	Pattern Groups							
+								
+	Group Name	Pattern File	Comment					
+% end
+% collection.each do |patgroup|
+<%= patgroup %>
+% end    

data/lib/origen/tester/j750/generator/templates/patsets.txt.erb

@@ -0,0 +1,10 @@
+% unless @append
+DFF 1.1	Pattern Sets					
+						
+	Pattern Set	File/Group Name	Start Label	Stop Label	Comment	
+% end    
+% collection.each do |patset|
+%   patset.lines.each do |line|
+<%= line %>
+%   end
+% end