origen_testers 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f682217ab30f290fbde9388a14b9c7e63f00d7bb
-  data.tar.gz: 87288b479896b7e11d09b815f86339141f0a46ae
+  metadata.gz: d0f9e7b0562c602396e9cb070d57050486a854df
+  data.tar.gz: fbde57d2fa40beae37c0443261339bb2f8c187d7
 SHA512:
-  metadata.gz: bb4f04a3f01c882aa949740d9caf1e9c684aa63a1f7e64c2ea81083be05419fbfbf8df399a560128fffaf8fdc25d346779c853b9c15e13442a54bf9995a6ee05
-  data.tar.gz: 4a02c66488678badc29a9cfcc2c972ab514071276a18dd6edece67eadd55b1a1951854b083c200d9942ae3952b89985e0d954929fd32cc7156859e8f8665e2e2
+  metadata.gz: f58d90428732f2046cf98e8b0c175531fd1a150eb86c8771beb3e766b2ec2de483f7cd7f72d8b1d74d78edcf6c9ece7fe9a587f5945b38cb8be88e793c915e07
+  data.tar.gz: c87af16d5020f20bdae4abcc3b6227e21f2c33d87c5e9f2d156e9d452f53840153ff1ceb1043586a0d257ebe27c30ca29f02c37ee64853e1cddbca89a7c61c48

data/config/boot.rb

@@ -5,7 +5,8 @@ require "origen_testers"
 require "origen_testers/test/dut.rb"
 require "origen_testers/test/block.rb"
 require "origen_testers/test/dut2.rb"
-require "origen_testers/test/dut3.rb"
+# NOTE: Before adding new duts-- consider adding option to DUT class 
+# so we don't reduce overall code coverage-- thx, mgmt
 require "origen_testers/test/nvm.rb"
 
 require "origen_testers/test/interface"

data/config/version.rb

@@ -1,6 +1,6 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 18
+  MINOR = 19
   BUGFIX = 0
   DEV = nil
 

data/lib/origen_testers/flow.rb

@@ -48,6 +48,11 @@ module OrigenTesters
       @lines
     end
 
+    def test(obj, options = {})
+      obj.extract_atp_attributes(options) if obj.respond_to?(:extract_atp_attributes)
+      super(obj, options)
+    end
+
     # @api private
     def self.ht_comments
       unless @ht_comments.is_a? Hash

data/lib/origen_testers/generator.rb

@@ -151,7 +151,6 @@ module OrigenTesters
     end
 
     def write_to_file(options = {})
-      c = caller[0]
       unless output_inhibited?
         if defined? self.class::TEMPLATE || Origen.tester.is_a?(OrigenTesters::Doc)
           write_from_template(options)
@@ -274,6 +273,7 @@ module OrigenTesters
       def new(*args, &block) # :nodoc:
         options = (args.last && args.last.is_a?(Hash)) ? args.last : {}
         x = allocate
+        x.filename = options[:filename] if options[:filename]
         x.send(:initialize, *args, &block)
         Origen.interface.sheet_generators << x unless options[:manually_register]
         x

data/lib/origen_testers/pattern_compilers/job.rb

@@ -22,13 +22,13 @@ module OrigenTesters
       # Pinmap file (IGXL-Based)
       attr_accessor :pinmap_workbook
 
-      # Pinmap file (Smartest-Based)
+      # Pin Config file (Smartest-Based)
       attr_accessor :pinconfig
 
-      # Pinmap file (Smartest-Based)
+      # Pattern input dir (Smartest-Based)
       attr_accessor :avc_dir
 
-      # Pinmap file (Smartest-Based)
+      # Pattern output dir (Smartest-Based)
       attr_accessor :binl_dir
 
       # Pattern count - should be 1 for IGXL; number of AVC files listed in AIV file for Smartest

data/lib/origen_testers/smartest_based_tester/base.rb

@@ -24,7 +24,44 @@ module OrigenTesters
       alias_method :min_repeat_count, :min_repeat_loop
       alias_method :min_repeat_count=, :min_repeat_loop=
 
+      # permit option to generate multiport type patterns
+      # and use multiport type code
+      attr_accessor :multiport
+      alias_method :multi_port, :multiport
+      alias_method :multi_port=, :multiport=
+      attr_accessor :multiport_prefix     # multiport burst name prefix
+      attr_accessor :multiport_postfix     # multiport burst name postfix
+
+      # When set to true, all test flows will be generated with a corresponding testtable limits
+      # file, rather than having the limits attached inline to the test suites
+      attr_accessor :create_limits_file
+
+      # Returns an array of strings that indicate which test modes will be included in limits files,
+      # by default returns an empty array.
+      # If no test modes have been specified then the limits file will simply be generated with no
+      # test modes.
+      attr_reader :limitfile_test_modes
+      alias_method :limitsfile_test_modes, :limitfile_test_modes
+
+      # When set to true, tests which are marked with continue: true will be forced to pass in
+      # generated test program flows. Flow branching based on the test result will be handled via
+      # some other means to give the same flow if the test 'fails', however the test will always
+      # appear as if it passed for data logging purposes.
+      #
+      # Testers which do not implement this option will ignore it.
+      attr_accessor :force_pass_on_continue
+
+      # When set to true, tests will be set to delayed binning by default (overon = on) unless
+      # delayed: false is supplied when defining the test
+      attr_accessor :delayed_binning
+
       def initialize(options = {})
+        options = {
+          # whether to use multiport bursts or not, if so this indicates the name of the port to use
+          multiport:         false,
+          multiport_prefix:  false,
+          multiport_postfix: false
+        }.merge(options)
         @max_repeat_loop = 65_535
         @min_repeat_loop = 33
         @pat_extension = 'avc'
@@ -35,7 +72,10 @@ module OrigenTesters
         @comment_char = '#'
         @level_period = true
         @inline_comments = true
-        @overlay_style = :subroutine		# default to use subroutine for overlay
+        @multiport = options[:multiport]
+        @multiport_prefix = options[:multiport_prefix]
+        @multiport_postfix = options[:multiport_postfix]
+        @overlay_style = :subroutine	# default to use subroutine for overlay
         @capture_style = :hram			# default to use hram for capture
         @overlay_subr = nil
 
@@ -47,6 +87,35 @@ module OrigenTesters
         else
           @unique_test_names = :signature
         end
+        if options.key?(:create_limits_file)
+          @create_limits_file = options[:create_limits_file]
+        else
+          @create_limits_file = false
+        end
+        self.limitfile_test_modes = options[:limitfile_test_modes] || options[:limitsfile_test_modes]
+        self.force_pass_on_continue = options[:force_pass_on_continue]
+        self.delayed_binning = options[:delayed_binning]
+      end
+
+      # Set the test mode(s) that you want to see in the limits files, supply an array of mode names
+      # to set multiple.
+      def limitfile_test_modes=(val)
+        @limitfile_test_modes = Array(val).map(&:to_s)
+      end
+      alias_method :limitsfile_test_modes, :limitfile_test_modes=
+
+      # return the multiport burst name
+      # provide the name you want to obtain multiport for
+      def multiport_name(patt_name)
+        name = "#{patt_name}"
+        if @multiport
+          name = "#{@multiport_prefix}_#{name}" if @multiport_prefix
+          name = "#{name}_#{@multiport_postfix}" if @multiport_postfix
+          unless @multiport_prefix || @multiport_postfix
+            name = "#{@multiport}_#{name}"
+          end
+        end
+        name
       end
 
       # Set to :enabled to have all top-level flow modules wrapped by an enable flow variable

data/lib/origen_testers/smartest_based_tester/base/flow.rb

@@ -43,6 +43,8 @@ module OrigenTesters
         end
 
         def at_flow_end
+          # Take whatever the test modes are set to at the end of the flow as what we go with
+          @test_modes = tester.limitfile_test_modes
         end
 
         def flow_header
@@ -86,14 +88,24 @@ module OrigenTesters
 
         def finalize(options = {})
           super
-          test_suites.finalize
-          test_methods.finalize
           @indent = add_flow_enable ? 2 : 1
           @lines = []
+          @open_test_methods = []
           @stack = { on_fail: [], on_pass: [] }
-          ast = atp.ast(unique_id: sig, optimization: :smt)
+          ast = atp.ast(unique_id: sig, optimization: :smt,
+                        implement_continue: !tester.force_pass_on_continue,
+                        optimize_flags_when_continue: !tester.force_pass_on_continue
+                       )
           @set_runtime_variables = ast.set_flags
           process(ast)
+          test_suites.finalize
+          test_methods.finalize
+          render_limits_file(ast) if tester.create_limits_file
+        end
+
+        def render_limits_file(ast)
+          m = platform::LimitsFile.new(self, ast, manually_register: true, filename: "#{name}_limits", test_modes: @test_modes)
+          m.write_to_file unless m.empty?
         end
 
         def line(str)
@@ -109,28 +121,61 @@ module OrigenTesters
         # end
 
         def on_test(node)
-          name = node.find(:object).to_a[0]
-          name = name.name unless name.is_a?(String)
+          test_suite = node.find(:object).to_a[0]
+          if test_suite.is_a?(String)
+            name = test_suite
+          else
+            name = test_suite.name
+            test_method = test_suite.test_method
+            if test_method.respond_to?(:test_name) && test_method.test_name == '' &&
+               n = node.find(:name)
+              test_method.test_name = n.value
+            end
+          end
+
           if node.children.any? { |n| t = n.try(:type); t == :on_fail || t == :on_pass } ||
              !stack[:on_pass].empty? || !stack[:on_fail].empty?
             line "run_and_branch(#{name})"
             process_all(node.to_a.reject { |n| t = n.try(:type); t == :on_fail || t == :on_pass })
+            on_pass = node.find(:on_pass)
+            on_fail = node.find(:on_fail)
+
+            if on_fail && on_fail.find(:continue) && tester.force_pass_on_continue
+              if test_method.respond_to?(:force_pass)
+                test_method.force_pass = 1
+              else
+                Origen.log.error 'Force pass on continue has been enabled, but the test method does not have a force_pass attribute!'
+                Origen.log.error "  #{node.source}"
+                exit 1
+              end
+              @open_test_methods << test_method
+            else
+              if test_method.respond_to?(:force_pass)
+                test_method.force_pass = 0
+              end
+              @open_test_methods << nil
+            end
+
             line 'then'
             line '{'
             @indent += 1
-            on_pass = node.children.find { |n| n.try(:type) == :on_pass }
-            process_all(on_pass) if on_pass
-            stack[:on_pass].each { |n| process_all(n) }
+            pass_branch do
+              process_all(on_pass) if on_pass
+              stack[:on_pass].each { |n| process_all(n) }
+            end
             @indent -= 1
             line '}'
             line 'else'
             line '{'
             @indent += 1
-            on_fail = node.children.find { |n| n.try(:type) == :on_fail }
-            process_all(on_fail) if on_fail
-            stack[:on_fail].each { |n| process_all(n) }
+            fail_branch do
+              process_all(on_fail) if on_fail
+              stack[:on_fail].each { |n| process_all(n) }
+            end
             @indent -= 1
             line '}'
+
+            @open_test_methods.pop
           else
             line "run(#{name});"
           end
@@ -228,7 +273,39 @@ module OrigenTesters
         def on_set_flag(node)
           flag = generate_flag_name(node.value)
           runtime_control_variables << flag
-          line "@#{flag} = 1;"
+          if @open_test_methods.last
+            if pass_branch?
+              if @open_test_methods.last.respond_to?(:on_pass_flag)
+                if @open_test_methods.last.on_pass_flag == ''
+                  @open_test_methods.last.on_pass_flag = flag
+                else
+                  Origen.log.error "The test method cannot set #{flag} on passing, because it already sets: #{@open_test_methods.last.on_pass_flag}"
+                  Origen.log.error "  #{node.source}"
+                  exit 1
+                end
+              else
+                Origen.log.error 'Force pass on continue has been requested, but the test method does not have an :on_pass_flag attribute:'
+                Origen.log.error "  #{node.source}"
+                exit 1
+              end
+            else
+              if @open_test_methods.last.respond_to?(:on_fail_flag)
+                if @open_test_methods.last.on_fail_flag == ''
+                  @open_test_methods.last.on_fail_flag = flag
+                else
+                  Origen.log.error "The test method cannot set #{flag} on failing, because it already sets: #{@open_test_methods.last.on_fail_flag}"
+                  Origen.log.error "  #{node.source}"
+                  exit 1
+                end
+              else
+                Origen.log.error 'Force pass on continue has been requested, but the test method does not have an :on_fail_flag attribute:'
+                Origen.log.error "  #{node.source}"
+                exit 1
+              end
+            end
+          else
+            line "@#{flag} = 1;"
+          end
         end
 
         def on_group(node)
@@ -257,7 +334,11 @@ module OrigenTesters
           if node.to_a[0] == 'pass'
             line "stop_bin \"#{sbin}\", \"\", , good, noreprobe, green, #{bin}, over_on;"
           else
-            line "stop_bin \"#{sbin}\", \"#{sdesc}\", , bad, noreprobe, red, #{bin}, over_on;"
+            if tester.create_limits_file
+              line 'multi_bin;'
+            else
+              line "stop_bin \"#{sbin}\", \"#{sdesc}\", , bad, noreprobe, red, #{bin}, over_on;"
+            end
           end
         end
 
@@ -282,6 +363,30 @@ module OrigenTesters
 
         private
 
+        def pass_branch
+          open_branch_types << :pass
+          yield
+          open_branch_types.pop
+        end
+
+        def fail_branch
+          open_branch_types << :fail
+          yield
+          open_branch_types.pop
+        end
+
+        def pass_branch?
+          open_branch_types.last == :pass
+        end
+
+        def fail_branch?
+          open_branch_types.last == :fail
+        end
+
+        def open_branch_types
+          @open_branch_types ||= []
+        end
+
         def generate_flag_name(flag)
           case flag[0]
           when '$'

data/lib/origen_testers/smartest_based_tester/base/limits_file.rb

@@ -0,0 +1,216 @@
+require 'origen_testers/smartest_based_tester/base/processors/extract_bin_names'
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class LimitsFile < ATP::Formatter
+        include OrigenTesters::Generator
+
+        attr_reader :ast, :flow, :test_modes, :flowname, :bin_names
+
+        def initialize(flow, ast, options = {})
+          @flow = flow
+          @ast = ast
+          @flowname = flow.filename.sub(/\..*/, '') # Base off the filename since it will include any prefix
+          @used_test_numbers = {}
+          @bin_names = Processors::ExtractBinNames.new.run(ast)
+          @test_modes = Array(options[:test_modes])
+          @empty = true
+          l = '"Suite name","Pins","Test name","Test number"'
+          if test_modes.empty?
+            l += ',"Lsl","Lsl_typ","Usl_typ","Usl","Units","Bin_s_num","Bin_s_name","Bin_h_num","Bin_h_name","Bin_type","Bin_reprobe","Bin_overon","Test_remarks"'
+            lines << l
+          else
+            l += (',"Lsl","Lsl_typ","Usl_typ","Usl","Units"' * test_modes.size) + ',"Bin_s_num","Bin_s_name","Bin_h_num","Bin_h_name","Bin_type","Bin_reprobe","Bin_overon","Test_remarks"'
+            lines << l
+            l = '"Test mode",,,'
+            test_modes.each do |mode|
+              l += ",\"#{mode}\",\"#{mode}\",\"#{mode}\",\"#{mode}\",\"#{mode}\""
+            end
+            l += ',,,,,,,,'
+            lines << l
+          end
+          process(ast)
+        end
+
+        def lines
+          @lines ||= []
+        end
+
+        def subdirectory
+          'testtable/limits'
+        end
+
+        def on_test(node)
+          o = {}
+          o[:suite_name] = extract_test_suite_name(node, o)
+
+          lines << line(extract_line_options(node, o))
+
+          node.find_all(:sub_test).each do |sub_test|
+            lines << line(extract_line_options(sub_test, o.dup))
+          end
+
+          process_all(node.children)
+        end
+
+        # Returns true if the AST provided when initializing this limits table generator did not
+        # contain any tests, i.e. the resultant limits file is empty
+        def empty?
+          @empty
+        end
+
+        private
+
+        def extract_line_options(node, o)
+          o[:test_name] = extract_test_name(node, o)
+          o[:test_number] = extract_test_number(node, o)
+          o[:limits] = extract_limits(node, o)
+          if on_fail = node.find(:on_fail)
+            if set_result = on_fail.find(:set_result)
+              if bin = set_result.find(:bin)
+                o[:bin_h_num] = bin.to_a[0] || o[:bin_h_num]
+                o[:bin_h_name] = bin_names[:hard][bin.to_a[0]][:name]
+              end
+              if sbin = set_result.find(:softbin)
+                o[:bin_s_num] = sbin.to_a[0] || o[:bin_s_num]
+                o[:bin_s_name] = bin_names[:soft][sbin.to_a[0]][:name]
+              end
+            end
+            delayed = on_fail.find(:delayed)
+            if delayed && !delayed.to_a[0]
+              o[:bin_overon] = 'no'
+            elsif (delayed && delayed.to_a[0]) || tester.delayed_binning
+              o[:bin_overon] = 'on'
+            else
+              o[:bin_overon] = 'no'
+            end
+          end
+          o
+        end
+
+        def extract_limits(node, o)
+          modes = test_modes
+          lims = {}
+          (modes + [nil]).each do |mode|
+            lims[mode] = {}
+            if node.find(:nolimits)
+              lims[mode][:lsl] = nil
+              lims[mode][:lsl_typ] = 'NA'
+              lims[mode][:usl] = nil
+              lims[mode][:usl_typ] = 'NA'
+            else
+              limits = node.find_all(:limit)
+              if limits.empty?
+                # Assume it is a functional test in this case
+                lims[mode][:lsl] = 0
+                lims[mode][:lsl_typ] = 'GE'
+                lims[mode][:usl] = 0
+                lims[mode][:usl_typ] = 'LE'
+              else
+                limits.find_all { |l| l.to_a[3].to_s == mode.to_s }.each do |limit|
+                  limit = limit.to_a
+                  if limit[1] =~ /^G/i
+                    lims[mode][:lsl] = limit[0]
+                    lims[mode][:lsl_typ] = limit[0] ? limit[1].to_s.upcase : nil
+                    lims[mode][:lsl_typ] = 'GE' if lims[mode][:lsl_typ] == 'GTE'
+                  else
+                    lims[mode][:usl] = limit[0]
+                    lims[mode][:usl_typ] = limit[0] ? limit[1].to_s.upcase : nil
+                    lims[mode][:usl_typ] = 'LE' if lims[mode][:usl_typ] == 'LTE'
+                  end
+                  lims[mode][:units] = limit[2]
+                end
+              end
+            end
+          end
+          lims
+        end
+
+        def extract_test_number(node, o)
+          number = (node.find(:number) || []).to_a[0]
+          if number
+            if n1 = @used_test_numbers[number]
+              if n1.has_source? && node.has_source?
+                Origen.log.error "Test number #{number} has been assigned more than once in limits file #{filename} (flow: #{flowname}):"
+                Origen.log.error "  #{n1.source}"
+                Origen.log.error "  #{node.source}"
+                exit 1
+              else
+                fail "Test number #{number} cannot be assigned to #{o[:suite_name]} in limits file #{filename} (flow: #{flowname}), since it has already be used for #{@used_test_numbers[number]}!"
+              end
+            end
+            @used_test_numbers[number] = node
+            number
+          end
+        end
+
+        def extract_test_suite_name(node, o)
+          test_obj = node.find(:object).to_a[0]
+          test_obj.respond_to?(:name) ? test_obj.name : test_obj if test_obj
+        end
+
+        def extract_test_name(node, o)
+          (node.find(:name) || []).to_a[0] || extract_test_suite_name(node, o) || o[:suite_name]
+        end
+
+        def line(options)
+          @empty = false
+          # "Suite name"
+          l = "\"#{options[:suite_name]}\""
+          # "Pins"
+          l << f(options[:pins])
+          # "Test name"
+          l << f(options[:test_name])
+          # "Test number"
+          l << f(options[:test_number])
+          if test_modes.empty?
+            # "Lsl"
+            l << f((options[:limits][nil] || {})[:lsl])
+            # "Lsl_typ"
+            l << f((options[:limits][nil] || {})[:lsl_typ])
+            # "Usl_typ"
+            l << f((options[:limits][nil] || {})[:usl_typ])
+            # "Usl"
+            l << f((options[:limits][nil] || {})[:usl])
+            # "Units"
+            l << f((options[:limits][nil] || {})[:units])
+          else
+            test_modes.each do |mode|
+              # "Lsl"
+              l << f((options[:limits][mode] || options[:limits][nil] || {})[:lsl])
+              # "Lsl_typ"
+              l << f((options[:limits][mode] || options[:limits][nil] || {})[:lsl_typ])
+              # "Usl_typ"
+              l << f((options[:limits][mode] || options[:limits][nil] || {})[:usl_typ])
+              # "Usl"
+              l << f((options[:limits][mode] || options[:limits][nil] || {})[:usl])
+              # "Units"
+              l << f((options[:limits][mode] || options[:limits][nil] || {})[:units])
+            end
+          end
+          # "Bin_s_num"
+          l << f(options[:bin_s_num])
+          # "Bin_s_name"
+          l << f(options[:bin_s_name])
+          # "Bin_h_num"
+          l << f(options[:bin_h_num])
+          # "Bin_h_name"
+          l << f(options[:bin_h_name])
+          # "Bin_type"
+          l << f(options[:bin_type])
+          # "Bin_reprobe"
+          l << f(options[:bin_reprobe])
+          # "Bin_overon"
+          l << f(options[:bin_overon])
+          # "Test_remarks"
+          l << f(options[:test_remarks])
+          l
+        end
+
+        def f(value)
+          ",\"#{value}\""
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/pattern_master.rb

@@ -41,11 +41,19 @@ module OrigenTesters
         # end
 
         def patterns
-          (references[:subroutine][:all] + references[:subroutine][:ate] +
+          return_arr = (references[:subroutine][:all] + references[:subroutine][:ate] +
             references[:main][:all] + references[:main][:ate]).map do |p|
             p = p.strip
             p += '.binl.gz' unless p =~ /binl.gz$/
           end.uniq
+          if $tester.multiport
+            return_arr += (references[:main][:all] + references[:main][:ate]).map do |p|
+              p = p.strip
+              p = $tester.multiport_name(p)
+              p += '.binl.gz' unless p =~ /.binl.gz$/
+            end.uniq
+          end
+          return_arr
         end
 
         def references

data/lib/origen_testers/smartest_based_tester/base/processors/extract_bin_names.rb

@@ -0,0 +1,64 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        class ExtractBinNames < ATP::Processor
+          def run(node, options = {})
+            @bin_names = { soft: {}, hard: {} }
+            process(node)
+            @bin_names
+          end
+
+          def on_bin_descriptions(node)
+            node.children.each do |n|
+              number, name = *n
+              record number, name, type: n.type
+            end
+          end
+
+          def on_test(node)
+            if on_fail = node.find(:on_fail)
+              if set_result = on_fail.find(:set_result)
+                if bin = set_result.find(:bin)
+                  if bin.to_a[1]
+                    record(*bin.to_a, supplied: true, type: :hard)
+                  else
+                    record(*bin.to_a, default_name(node), type: :hard)
+                  end
+                end
+                if sbin = set_result.find(:softbin)
+                  if sbin.to_a[1]
+                    record(*sbin.to_a, supplied: true, type: :soft)
+                  else
+                    record(*sbin.to_a, default_name(node), type: :soft)
+                  end
+                end
+              end
+            end
+            process_all(node.children)
+          end
+
+          private
+
+          def default_name(node)
+            test_obj = node.find(:object).to_a[0]
+            suite_name = test_obj.respond_to?(:name) ? test_obj.name : test_obj
+            test_name = (node.find(:name) || []).to_a[0] || suite_name
+            if suite_name == test_name
+              suite_name
+            else
+              "#{suite_name}_#{test_name}"
+            end
+          end
+
+          def record(number, name, options)
+            table = @bin_names[options[:type]]
+            if !table[number] || (options[:supplied] && !table[number][:supplied])
+              table[number] = { name: name, supplied: options[:supplied] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_method.rb

@@ -15,6 +15,7 @@ module OrigenTesters
         attr_reader :parameters
         attr_accessor :class_name
         attr_accessor :abs_class_name
+        attr_reader :limits
         attr_accessor :limits_id
 
         def initialize(options)
@@ -22,10 +23,6 @@ module OrigenTesters
           @library = options[:library]
           @class_name = options[:methods].delete(:class_name)
           @parameters = {}
-          # Add limits by default
-          define_singleton_method('limits') do
-            @limits
-          end
           @limits_id = options[:methods].delete(:limits_id)
           @limits = TestMethods::Limits.new(self)
           # Add any methods

data/lib/origen_testers/smartest_based_tester/base/test_methods/limits.rb

@@ -52,6 +52,17 @@ module OrigenTesters
             self.hi_limit = val
           end
 
+          def to_atp_attributes
+            r = []
+            if lo_limit
+              r << { value: lo_limit, rule: 'LE', units: unit }
+            end
+            if hi_limit
+              r << { value: hi_limit, rule: 'GE', units: unit }
+            end
+            r
+          end
+
           private
 
           def test_name

data/lib/origen_testers/smartest_based_tester/base/test_suite.rb

@@ -130,6 +130,9 @@ module OrigenTesters
         end
 
         def lines
+          if pattern
+            burst = $tester.multiport ? "#{$tester.multiport_name(pattern)}" : "#{pattern}"
+          end
           l = []
           l << "  comment = \"#{comment}\";" if comment
           l << "  ffc_on_fail = #{wrap_if_string(log_first)};" if log_first
@@ -139,7 +142,7 @@ module OrigenTesters
           l << "  override_lev_equ_set = #{wrap_if_string(level_equation)};" if level_equation
           l << "  override_lev_spec_set = #{wrap_if_string(level_spec)};" if level_spec
           l << "  override_levset = #{wrap_if_string(level_set)};" if level_set
-          l << "  override_seqlbl = #{wrap_if_string(pattern)};" if pattern
+          l << "  override_seqlbl = #{wrap_if_string(burst)};" if pattern
           l << "  override_test_number = #{test_number};" if test_number
           l << "  override_testf = #{test_method.id};" if test_method
           l << "  override_tim_equ_set = #{wrap_if_string(timing_equation)};" if timing_equation
@@ -171,6 +174,10 @@ module OrigenTesters
           meta || {}
         end
 
+        def extract_atp_attributes(options)
+          options[:limits] ||= limits.to_atp_attributes
+        end
+
         private
 
         def flags

data/lib/origen_testers/smartest_based_tester/v93k/limits_file.rb

@@ -0,0 +1,10 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K
+      require 'origen_testers/smartest_based_tester/base/limits_file'
+      class LimitsFile < Base::LimitsFile
+        TEMPLATE = "#{Origen.root!}/lib/origen_testers/smartest_based_tester/v93k/templates/limits.csv.erb"
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/v93k/templates/limits.csv.erb

@@ -0,0 +1,3 @@
+% lines.each do |line|
+<%= line %>
+% end

data/lib/origen_testers/smartest_based_tester/v93k/templates/template.aiv.erb

@@ -8,10 +8,25 @@ single_binary_pattern_dir       ./BINL/
  
 AI_V2B_OPTIONS  -ALT -c <%= $dut.name.to_s.upcase %>.vbc -k -z PS800
 
+% if $tester.multiport
+PATTERNS name tmf_file port v2b_options
+%   port = !!$tester.multiport ? " #{$tester.multiport}" : ''
+% else
 PATTERNS name tmf_file v2b_options
+% end
 %   subroutines.each do |pattern|
-<%= pattern %> <%= $dut.name.to_s.upcase %>.tmf -s
+<%= pattern %> <%= $dut.name.to_s.upcase %>.tmf<%= port %> -s
 %   end
 %   patterns.each do |pattern|
-<%= pattern %> <%= $dut.name.to_s.upcase %>.tmf
+<%= pattern %> <%= $dut.name.to_s.upcase %>.tmf<%= port %>
 %   end
+%#-
+% if $tester.multiport
+%   patterns.each do |pattern|
+
+MULTI_PORT_BURST "<%= "#{$tester.multiport_name(pattern)}" %>" 
+PORTS     <%= $tester.multiport %>                                  
+SEQ_GRPS  grp1                                  
+          <%= pattern %>
+%   end
+% end

data/lib/origen_testers/smartest_based_tester/v93k/templates/template.tf.erb

@@ -124,6 +124,7 @@ end
 -----------------------------------------------------------------
 testmethodlimits
 
+% unless tester.create_limits_file
 % if program
 %   program.testmethodlimits.each do |id, parameters|
 <%= id %>:
@@ -139,6 +140,7 @@ testmethodlimits
 %     end
 %   end
 % end
+% end
 
 end
 -----------------------------------------------------------------

data/lib/origen_testers/test/dut.rb

@@ -16,10 +16,26 @@ module OrigenTesters
       include OrigenJTAG
 
       def initialize(options = {})
+        options = {
+          test_generic_overlay_capture: false
+        }.merge(options)
+
+        @test_options = {
+          test_generic_overlay_capture: options[:test_generic_overlay_capture]
+        }
+
         add_pin :tclk
         add_pin :tdi
         add_pin :tdo
         add_pin :tms
+        if @test_options[:test_generic_overlay_capture]
+          # approved patts for this test type do not use these
+          add_pin :pa0
+          add_pin :pa1
+          add_pin :pa2
+          add_pin_group :pa, :pa2, :pa1, :pa0
+          add_pin_alias :tdi_a, :tdi
+        end
         # add_pin_group :jtag, :tdi, :tdo, :tms
         add_power_pin_group :vdd1
         add_power_pin_group :vdd2
@@ -32,23 +48,28 @@ module OrigenTesters
           reg.bits 1,      :done
           reg.bits 0,      :enable
         end
-        @hv_supply_pin = 'VDDHV'
-        @lv_supply_pin = 'VDDLV'
-        @digsrc_pins = [:tdi, :tms]
-        @digsrc_settings = { digsrc_mode: :parallel, digsrc_bit_order: :msb }
-        @digcap_pins = :tdo
-        @digcap_settings = { digcap_format: :twos_complement }
+        unless @test_options[:test_generic_overlay_capture]
+          # approved patts for this test type do not use these
+          @hv_supply_pin = 'VDDHV'
+          @lv_supply_pin = 'VDDLV'
+          @digsrc_pins = [:tdi, :tms]
+          @digsrc_settings = { digsrc_mode: :parallel, digsrc_bit_order: :msb }
+          @digcap_pins = :tdo
+          @digcap_settings = { digcap_format: :twos_complement }
+        end
         @blocks = [Block.new(0, self), Block.new(1, self), Block.new(2, self)]
       end
 
       def on_create
-        if tester && tester.uflex?
-          tester.assign_dc_instr_pins([hv_supply_pin, lv_supply_pin])
-          tester.assign_digsrc_pins(digsrc_pins)
-          tester.apply_digsrc_settings(digsrc_settings)
-          tester.assign_digcap_pins(digcap_pins)
-          tester.apply_digcap_settings(digcap_settings)
-          tester.memory_test_en = true
+        unless @test_options[:test_generic_overlay_capture]
+          if tester && tester.uflex?
+            tester.assign_dc_instr_pins([hv_supply_pin, lv_supply_pin])
+            tester.assign_digsrc_pins(digsrc_pins)
+            tester.apply_digsrc_settings(digsrc_settings)
+            tester.assign_digcap_pins(digcap_pins)
+            tester.apply_digcap_settings(digcap_settings)
+            tester.memory_test_en = true
+          end
         end
       end
 

data/program/test.rb

@@ -10,16 +10,21 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
 
 #  para 'charge_pump', :high_voltage => true, :lo_limit => 5, :hi_limit => 6
 
+  if tester.v93k? && tester.create_limits_file
+    func :program_ckbd, :number => 1000, :bin => 100, :soft_bin => 1100
+  end
   meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, lo_limit: 35, number: 40000
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, number: 40010
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35, number: 40020
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35, number: 40030
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, number: 40040
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, continue: true, number: 40050
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 2000, lo_limit: 0.01, continue: true, number: 40060
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: "_some_spec", lo_limit: 0.01, continue: true, number: 40070
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: [1, 2], number: 40080
-  meas :read_pump, tnum: 1050, bin: 119, soft_bin: 2, lo_limit: [1.uA, 2.uA, 3.uA], hi_limit: [4.uA,5.uA], units: "A", defer_limits: true, number: 40090
+  meas :read_pump, tnum: 1060, bin: 119, soft_bin: 2, hi_limit: 45, number: 40010
+  meas :read_pump, tnum: 1070, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35, number: 40020
+  meas :read_pump, tnum: 1080, bin: 119, soft_bin: 2, hi_limit: 45, lo_limit: 35, number: 40030
+  meas :read_pump, tnum: 1090, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, number: 40040
+  meas :read_pump, tnum: 1100, bin: 119, soft_bin: 2, hi_limit: 45.mV, lo_limit: 35.mV, continue: true, number: 40050
+  meas :read_pump, tnum: 1110, bin: 119, soft_bin: 2, hi_limit: 2000, lo_limit: 0.01, continue: true, number: 40060
+  unless tester.v93k? && tester.create_limits_file
+    meas :read_pump, tnum: 1120, bin: 119, soft_bin: 2, hi_limit: "_some_spec", lo_limit: 0.01, continue: true, number: 40070
+    meas :read_pump, tnum: 1130, bin: 119, soft_bin: 2, hi_limit: [1, 2], number: 40080
+    meas :read_pump, tnum: 1140, bin: 119, soft_bin: 2, lo_limit: [1.uA, 2.uA, 3.uA], hi_limit: [4.uA,5.uA], units: "A", defer_limits: true, number: 40090
+  end
 
   if tester.uflex?
     log "Test of ultraflex render API"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-03 00:00:00.000000000 Z
+date: 2018-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -254,9 +254,10 @@ files:
 - lib/origen_testers/smartest_based_tester/base.rb
 - lib/origen_testers/smartest_based_tester/base/flow.rb
 - lib/origen_testers/smartest_based_tester/base/generator.rb
+- lib/origen_testers/smartest_based_tester/base/limits_file.rb
 - lib/origen_testers/smartest_based_tester/base/pattern_compiler.rb
 - lib/origen_testers/smartest_based_tester/base/pattern_master.rb
-- lib/origen_testers/smartest_based_tester/base/processors/extract_set_variables.rb
+- lib/origen_testers/smartest_based_tester/base/processors/extract_bin_names.rb
 - lib/origen_testers/smartest_based_tester/base/test_method.rb
 - lib/origen_testers/smartest_based_tester/base/test_methods.rb
 - lib/origen_testers/smartest_based_tester/base/test_methods/ac_tml.rb
@@ -273,8 +274,10 @@ files:
 - lib/origen_testers/smartest_based_tester/v93k/builder/pattern_master.rb
 - lib/origen_testers/smartest_based_tester/v93k/flow.rb
 - lib/origen_testers/smartest_based_tester/v93k/generator.rb
+- lib/origen_testers/smartest_based_tester/v93k/limits_file.rb
 - lib/origen_testers/smartest_based_tester/v93k/pattern_compiler.rb
 - lib/origen_testers/smartest_based_tester/v93k/pattern_master.rb
+- lib/origen_testers/smartest_based_tester/v93k/templates/limits.csv.erb
 - lib/origen_testers/smartest_based_tester/v93k/templates/template.aiv.erb
 - lib/origen_testers/smartest_based_tester/v93k/templates/template.pmfl.erb
 - lib/origen_testers/smartest_based_tester/v93k/templates/template.tf.erb
@@ -289,7 +292,6 @@ files:
 - lib/origen_testers/test/custom_test_interface.rb
 - lib/origen_testers/test/dut.rb
 - lib/origen_testers/test/dut2.rb
-- lib/origen_testers/test/dut3.rb
 - lib/origen_testers/test/interface.rb
 - lib/origen_testers/test/nvm.rb
 - lib/origen_testers/timing.rb
@@ -362,7 +364,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: This plugin provides Origen tester models to drive ATE type testers like

data/lib/origen_testers/smartest_based_tester/base/processors/extract_set_variables.rb

@@ -1,22 +0,0 @@
-module OrigenTesters
-  module SmartestBasedTester
-    class Base
-      module Processors
-        # Extracts all runtime variables which are set within the given flow, returning
-        # them in an array
-        class ExtractSetVariables < ATP::Processor
-          def run(nodes)
-            @results = []
-            process_all(nodes)
-            @results.uniq
-          end
-
-          def on_set_flag(node)
-            flag = node.value
-            @results << flag
-          end
-        end
-      end
-    end
-  end
-end

data/lib/origen_testers/test/dut3.rb

@@ -1,244 +0,0 @@
-module OrigenTesters
-  module Test
-    class DUT3
-      # Simple DUT using Nexus interface
-
-      attr_accessor :blocks
-      attr_accessor :hv_supply_pin
-      attr_accessor :lv_supply_pin
-      attr_accessor :digsrc_pins
-      attr_accessor :digcap_pins
-      attr_accessor :digsrc_settings
-      attr_accessor :digcap_settings
-
-      include OrigenARMDebug
-      include Origen::TopLevel
-      include OrigenJTAG
-
-      def initialize(options = {})
-        add_pin :tclk
-        add_pin :tdi
-        add_pin :tdo
-        add_pin :tms
-        add_pin :pa0
-        add_pin :pa1
-        add_pin :pa2
-        add_pin_group :pa, :pa2, :pa1, :pa0
-        add_pin_alias :tdi_a, :tdi
-        # add_pin_group :jtag, :tdi, :tdo, :tms
-        add_power_pin_group :vdd1
-        add_power_pin_group :vdd2
-        add_virtual_pin :virtual1, type: :virtual_pin
-        add_virtual_pin :virtual2, type: :ate_ch
-
-        reg :testme32, 0x007a do |reg|
-          reg.bits 31..16, :portB
-          reg.bits 15..8,  :portA
-          reg.bits 1,      :done
-          reg.bits 0,      :enable
-        end
-        @blocks = [Block.new(0, self), Block.new(1, self), Block.new(2, self)]
-      end
-
-      def startup(options)
-        $tester.set_timeset('tp0', 60)
-      end
-
-      def write_register(reg, options = {})
-        arm_debug.write_register(reg, options)
-      end
-
-      def read_register(reg, options = {})
-        arm_debug.write_register(reg, options)
-      end
-
-      def execute(options = {})
-        options = { define:    false,          # whether to define subr or call it
-                    name:      'executefunc1',
-                    onemodsub: false        # whether to expects subr to be in single module
-                }.merge(options)
-
-        if options[:define]
-          # define subroutine
-          $tester.start_subroutine(options[:name], onemodsub: options[:onemodsub])
-          $tester.cycle
-          $tester.end_subroutine(onemodsub: options[:onemodsub])
-          $tester.cycle unless options[:onemodsub]
-        else
-          # call subroutine
-          $tester.cycle
-          $tester.call_subroutine(options[:name])
-          $tester.cycle
-        end
-      end
-
-      # Match loop functionality
-      def match(options = {})
-        options = { type:        :match_pin,    # whether to match DONE bit in register or match pin
-                    # :match_done
-                    # :match_2pins
-                    delay_in_us: 5,           # match loop delay
-                    define:      false,       # whether to define subr or call it
-                    subr_name:   false,       # default use match type as subr name
-                }.merge(options)
-
-        subr_name = options[:subr_name] ? options[:subr_name] : options[:type].to_s
-
-        if options[:define]
-          $tester.start_subroutine(subr_name)
-          $tester.cycle
-          if options[:type] == :match_done
-
-            # Match DONE bit in register
-            $tester.wait(match:                 true,
-                         time_in_us:            options[:delay_in_us],
-                         global_loops:          true,
-                         check_for_fails:       true,
-                         force_fail_on_timeout: true,
-                         clr_fail_post_match:   true,
-                         manual_stop:           true) do
-              # Match on reading done bit
-              reg(:testme32).bits(:done).write(1)
-              reg(:testme32).bits(:done).read!
-            end
-          elsif options[:type] == :match_pin
-            # Match on TDO pin state
-            $tester.wait(match:                 true,
-                         pin:                   pin(:tdo),
-                         state:                 :high,
-                         time_in_us:            options[:delay_in_us],
-                         global_loops:          true,
-                         check_for_fails:       true,
-                         force_fail_on_timeout: true,
-                         clr_fail_post_match:   true,
-                         manual_stop:           true)
-          elsif options[:type] == :match_2pins
-            # Match on TDO pin state
-            $tester.wait(match:                 true,
-                         pin:                   pin(:tdo),
-                         state:                 :high,
-                         pin2:                  pin(:tms),
-                         state2:                :high,
-                         time_in_us:            options[:delay_in_us],
-                         global_loops:          true,
-                         check_for_fails:       true,
-                         force_fail_on_timeout: true,
-                         clr_fail_post_match:   true,
-                         manual_stop:           true)
-          elsif options[:type] == :multiple_entries
-            # Match on TDO pin state, with multiple subr entry points
-            $tester.wait(match:                 true,
-                         pin:                   pin(:tdo),
-                         state:                 :high,
-                         time_in_us:            options[:delay_in_us],
-                         global_loops:          true,
-                         multiple_entries:      true,
-                         check_for_fails:       true,
-                         force_fail_on_timeout: true,
-                         clr_fail_post_match:   true,
-                         manual_stop:           true)
-          end
-          $tester.cycle
-          $tester.end_subroutine
-          $tester.cycle
-        else
-          # call subroutine
-          $tester.cycle
-          $tester.call_subroutine(subr_name)
-          $tester.cycle
-        end
-      end
-
-      def handshake(options = {})
-        options = {
-          define: false,          # whether to define subr or call it
-        }.merge(options)
-
-        if options[:define]
-          $tester.start_subroutine('handshake')
-          $tester.handshake(readcode: 100)
-          $tester.cycle
-          $tester.cycle
-          $tester.cycle
-          $tester.end_subroutine
-        else
-          $tester.cycle
-          $tester.call_subroutine('handshake')
-        end
-      end
-
-      def digsrc_overlay(options = {})
-        options = { define:            false,       # whether to define subr or call it
-                    subr_name:         false,       # default use match type as subr name
-                    digsrc_pins:       @digsrc_pins, # defaults to what's defined in $dut
-                    overlay_reg:       nil, # defaults to testme32 register
-                    overlay_cycle_num: 32, # Only needed if overlay_reg is NOT nil, this specificies how many clk cycles to overlay.
-                }.merge(options)
-        if options[:define]
-          $tester.start_subroutine(options[:subr_name]) # Start subroutine
-          digsrc_pins = $tester.assign_digsrc_pins(options[:digsrc_pins])
-          $tester.digsrc_start(digsrc_pins, dssc_mode: :single)
-          original_pin_states = {}
-          digsrc_pins.each do |pin|
-            original_pin_states.merge!(pin => pin(pin).data)
-            pin(pin).drive_mem
-          end
-          if options[:overlay_reg].nil?
-            options[:overlay_cycle_num].times do
-              $tester.digsrc_send(digsrc_pins)
-              $tester.cycle
-            end
-          else
-            $tester.dont_compress = true
-            options[:overlay_reg].size.times do
-              $tester.digsrc_send(digsrc_pins)
-              $tester.cycle
-            end
-          end
-          original_pin_states.each do |pin, state|
-            pin(pin).drive(state)
-          end
-          $tester.digsrc_stop(digsrc_pins)
-          $tester.cycle
-          $tester.end_subroutine # end subroutine
-        else
-          $tester.cycle
-          $tester.call_subroutine(options[:subr_name])
-        end
-      end
-
-      def memory_test(options = {})
-        options = {
-        }.merge(options)
-
-        $tester.memory_test(inc_counter_x: true, gen_vector: true)
-
-        $tester.memory_test(inc_counter_y: true, gen_vector: true)
-
-        $tester.memory_test(init_counter_x: true)
-
-        $tester.memory_test(inc_counter_x: true, init_counter_y: true)
-
-        $tester.memory_test(inc_counter_y: true, capture_vector: true)
-
-        $tester.memory_test(pin: pin(:tdo), pin_data: :expect)
-      end
-
-      def freq_count(options = {})
-        options = {
-        }.merge(options)
-
-        $tester.freq_count($dut.pin(:tdo), readcode: 73)
-      end
-
-      # dummy flag to check for a particular design bug for this DUT
-      def has_margin0_bug?
-        false
-      end
-
-      def find_block_by_id(id)
-        @blocks.find { |block| block.id == id }
-      end
-    end
-  end
-end