origen_testers 0.45.3 → 0.48.0

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

@@ -85,7 +85,13 @@ module OrigenTesters
           end
           # Finally set any initial values that have been supplied
           options[:attrs].each do |k, v|
-            send("#{k}=", v) if respond_to?("#{k}=")
+            accessor = "#{k}="
+            if respond_to?(accessor)
+              send(accessor, v)
+            else
+              accessor = "#{k.to_s.underscore}="
+              send(accessor, v) if respond_to?(accessor)
+            end
           end
         end
 

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

@@ -13,14 +13,14 @@ module OrigenTesters
 
           def method_missing(method, *args, &block)
             if definitions[method]
-              m = platform::TestMethod.new methods: definitions[method].dup,
-                                           attrs:   (args.first || {}),
-                                           type:    method,
-                                           library: self
-              test_methods.add(m)
-              m
+              instantiate_test_method(method, args)
             else
-              super
+              method = method.to_s.underscore.to_sym
+              if definitions[method]
+                instantiate_test_method(method, args)
+              else
+                super
+              end
             end
           end
 
@@ -31,6 +31,17 @@ module OrigenTesters
           def definitions
             @definitions || self.class::TEST_METHODS
           end
+
+          private
+
+          def instantiate_test_method(method, args)
+            m = platform::TestMethod.new methods: definitions[method].dup,
+                                         attrs:   (args.first || {}),
+                                         type:    method,
+                                         library: self
+            test_methods.add(m)
+            m
+          end
         end
       end
     end

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

@@ -9,7 +9,7 @@ module OrigenTesters
               test_current:          [:current, 10.uA],
               settling_time:         [:time, 1.ms],
               measurement_mode:      [:string, 'PPMUpar', %w(PPMUpar ProgLoad)],
-              polarity:              [:string, 'SPOL', ['SPOL' 'BPOL']],
+              polarity:              [:string, 'SPOL', %w(SPOL BPOL)],
               precharge_to_zero_vol: [:string, 'ON', %w(ON OFF)],
               test_name:             [:string, 'passVolt_mv'],
               output:                [:string, 'None', %w(None ReportUI ShowFailOnly)]

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

@@ -6,13 +6,13 @@ module OrigenTesters
         include OrigenTesters::Generator
 
         attr_reader :variables
-        attr_accessor :filename, :id
+        attr_accessor :filename, :id, :subdirectory
 
         def initialize(options = {})
         end
 
         def subdirectory
-          'testflow/mfh.testflow.setup'
+          @subdirectory ||= 'testflow/mfh.testflow.setup'
         end
 
         def add_variables(vars)
@@ -35,21 +35,25 @@ module OrigenTesters
 
         # What SMT7 calls a flag
         def flags
-          (variables[:all][:referenced_enables] + variables[:all][:set_enables]).uniq.sort do |x, y|
-            x = x[0] if x.is_a?(Array)
-            y = y[0] if y.is_a?(Array)
-            # Need to use strings for the comparison as some flags can be a string and some a symbol
-            x.to_s <=> y.to_s
+          if variables
+            (variables[:all][:referenced_enables] + variables[:all][:set_enables]).uniq.sort do |x, y|
+              x = x[0] if x.is_a?(Array)
+              y = y[0] if y.is_a?(Array)
+              # Need to use strings for the comparison as some flags can be a string and some a symbol
+              x.to_s <=> y.to_s
+            end
           end
         end
 
         # What SMT7 calls a declaration
         def declarations
-          (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[:all][:set_flags]).uniq.sort do |x, y|
-            x = x[0] if x.is_a?(Array)
-            y = y[0] if y.is_a?(Array)
-            # Need to use strings for the comparison as some declarations can be a string and some a symbol
-            x.to_s <=> y.to_s
+          if variables
+            (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[:all][:set_flags]).uniq.sort do |x, y|
+              x = x[0] if x.is_a?(Array)
+              y = y[0] if y.is_a?(Array)
+              # Need to use strings for the comparison as some declarations can be a string and some a symbol
+              x.to_s <=> y.to_s
+            end
           end
         end
 

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

@@ -3,11 +3,13 @@ language_revision = 1;
 
 declarations
 
-% declarations.each do |var|
-%   if var.is_a?(Array)
+% if declarations
+%   declarations.each do |var|
+%     if var.is_a?(Array)
 @<%= var[0].to_s %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
-%   else
+%     else
 @<%= var.to_s %> = 0;
+%     end
 %   end
 % end
 
@@ -15,11 +17,13 @@ end
 -----------------------------------------------------------------
 flags
 
-% flags.each do |var|
-%   if var.is_a?(Array)
+% if flags
+%   flags.each do |var|
+%     if var.is_a?(Array)
 user <%= var[0].to_s %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
-%   else
+%     else
 user <%= var.to_s %> = 0;
+%     end
 %   end
 % end
 

data/lib/origen_testers/test/interface.rb

@@ -2,6 +2,7 @@ module OrigenTesters
   module Test
     class Interface
       include OrigenTesters::ProgramGenerators
+      include OrigenTesters::Charz
 
       attr_accessor :include_additional_prb2_test
       attr_reader :environment
@@ -10,6 +11,45 @@ module OrigenTesters
       # desired to configure your interface
       def initialize(options = {})
         @environment = options[:environment]
+        add_charz
+      end
+
+      def add_charz
+        add_charz_routine :routine1 do |routine|
+          routine.name = '_cz__rt1'
+        end
+        add_charz_routine :routine2 do |routine|
+          routine.name = '_cz__rt2'
+        end
+        add_charz_routine :routine3 do |routine|
+          routine.name = '_cz__rt3'
+        end
+        add_charz_routine :routine4 do |routine|
+          routine.name = '_cz__rt4'
+        end
+        add_charz_routine :routine5 do |routine|
+          routine.name = '_cz__rt5'
+        end
+        add_charz_routine :routine6 do |routine|
+          routine.name = '_cz__rt6'
+        end
+        add_charz_profile :cz do |profile|
+          profile.routines = [:routine3]
+        end
+        add_charz_profile :cz_only do |profile|
+          profile.charz_only = true
+          profile.routines = [:routine1]
+        end
+        add_charz_profile :simple_gates do |profile|
+          profile.flags = :my_flag
+          profile.enables = :my_enable
+          profile.routines = [:routine1]
+        end
+        add_charz_profile :complex_gates do |profile|
+          profile.flags = { ['$MyFlag1'] => [:routine1, :routine2], ['$MyFlag2'] => [:routine3], '$MyFlag3' => :routine4 }
+          profile.enables = { ['$MyEnable1'] => [:routine1], ['$MyEnable2'] => [:routine2, :routine3], '$MyEnable3' => :routine5 }
+          profile.routines = [:routine1, :routine2, :routine3, :routine4, :routine5, :routine6]
+        end
       end
 
       # Test that the block form of flow control methods like this can
@@ -86,6 +126,46 @@ module OrigenTesters
         end
       end
 
+      def func_with_charz(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        if tester.v93k?
+          if tester.smt7?
+            tm = test_methods.ac_tml.ac_test.functional_test
+            ts = test_suites.run(name, options)
+            ts.test_method = tm
+            ts.pattern = 'charz_example'
+
+            test_level_charz = false
+            if options[:charz]
+              charz_on(*options[:charz])
+              test_level_charz = true
+            end
+
+            unless charz_only? && !options[:charz_test]
+              options[:parent_test_name] = name
+              set_conditional_charz_id(options)
+              flow.test ts, options
+            end
+
+            unless options[:charz_test]
+              insert_charz_tests(options.merge(parent_test_name: name, charz_test: true)) do |options|
+                charz_name = :"#{name}_#{charz_routines[options[:current_routine]].name}"
+                func_with_charz(charz_name, options)
+              end
+            end
+
+            charz_off if test_level_charz
+          else
+            fail 'Only SMT7 is Implemented for Charz'
+          end
+        else
+          fail "Tester #{tester.name} Not Yet Implemented for Charz"
+        end
+      end
+
       def func_with_comment(name, options = {})
         if tester.v93k?
           options = {

data/pattern/tester_overlay_no_start.rb

@@ -0,0 +1,41 @@
+Pattern.create(name: "test_overlay_no_start") do
+  tester.overlay_style = :digsrc
+  # increase coverage by changing tdi dig src settings
+  tester.source_memory :digsrc do |mem| 
+    mem.pin :tdi, size: 32
+  end
+  cc 'should get a repeat count added to this vector for digsrc start minimum distance'
+  tester.cycle
+  
+  dut.pin(:tclk).drive(1)
+  dut.pin(:tdi).drive(1)
+  dut.pin(:tdo).assert(1)
+  dut.pin(:tms).drive(1)
+  
+  cc 'should get a repeat 5 vector'
+  tester.cycle repeat: 5
+
+  tester.digsrc_skip_start :tdi_a if tester.ultraflex?
+  tester.digsrc_skip_start :pa if tester.ultraflex?
+  
+  cc 'should get a send microcode and 1 cycle with D'
+  tester.cycle overlay: {overlay_str: 'dummy_str', pins: dut.pin(:tdi_a)}
+  cc 'should get a cycle with D and no send'
+  tester.cycle overlay: {overlay_str: 'dummy_str', pins: dut.pin(:tdi_a), change_data: false}
+  cc 'regular cycle with no D or send'
+  tester.cycle
+  
+  cc 'cycle with 001 on pa'
+  dut.pin(:pa).drive!(1)
+  cc 'send microcode followed by DDD on pa'
+  dut.pin(:pa).drive(0)
+  tester.cycle overlay: {overlay_str: "dummy_str", pins: dut.pin(:pa)}
+  cc 'cycle with 001 on pa'
+  dut.pin(:pa).drive!(1)
+  cc 'send microcode, DDD on pa with repeat 5 (will send 5 sets of data)'
+  dut.pin(:pa).drive(0)
+  tester.cycle repeat: 5, overlay: {overlay_str: "dummy_str", pins: dut.pin(:pa)}
+  cc 'cycle with 001 on pa'
+  dut.pin(:pa).drive!(1)
+  
+end

data/program/charz.rb

@@ -0,0 +1,48 @@
+# An instance of the interface is
+# passed in here, iterators and other
+# argument passing will be supported
+# similar to Pattern.create.
+Flow.create interface: 'OrigenTesters::Test::Interface' do
+  flow.flow_description = '' if tester.v93k?
+
+  if tester.v93k? && tester.smt7?
+    charz_on :complex_gates, { on_result: :fail }
+    func_with_charz :func_complex_gates_on_fail
+    charz_off
+
+    charz_on :complex_gates, { enables: :my_enable }
+    func_with_charz :func_complex_flag_simple_enable
+    charz_off
+
+    charz_on :complex_gates, { flags: :my_flag } do
+      func_with_charz :func_complex_enable_simple_flag
+    end
+
+    charz_on :cz_only, { placement: :eof }
+    func_with_charz :func_charz_only
+    charz_off
+
+    func_with_charz :func_test_level_routine, charz: [:routine1, { type: :routine }]
+
+    charz_on :cz
+    func_with_charz :func_skip_group, skip_group: true
+    charz_pause
+    func_with_charz :func_pause_charz
+    charz_resume
+    func_with_charz :func_resume_charz
+    charz_off
+
+    charz_on :simple_gates, { on_result: :pass } do 
+      func_with_charz :func_simple_gates_on_pass
+    end
+    
+    charz_on :simple_gates, { enables: nil }
+    func_with_charz :func_simple_flags
+    charz_off
+
+    charz_on :simple_gates, { flags: nil }
+    func_with_charz :func_simple_enables
+    charz_off
+  end
+
+end

data/program/prb1.rb

@@ -13,7 +13,7 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_description: 'Prob
   import 'test' # import top-level test.rb directly, note that Flow.create options of sub-flow will be ignored!
 
   # Test that a reference to a deeply nested test works (mainly for SMT8)
-  test :on_deep_1, if_failed: :deep_test
+  test :on_deep_1, if_failed: :deep_test, test_text: "some_custom_text"
 
   pass 1, description: "Good die!", softbin: 1
 end

data/templates/origen_guides/pattern/ultraflex.md.erb

@@ -7,4 +7,24 @@ automatically to any supported platform.
 There are no significant APIs in this category currently, therefore refer to the
 [Common Pattern API](<%= path "guides/pattern/common" %>) which can fully target the UltraFLEX.
 
+### DigSrc
+
+UltraFlex supports <code>:digsrc</code> as a <code>tester.overlay_style</code> set like this:
+
+~~~ruby
+  tester.overlay_style = :digsrc
+~~~
+
+By default Origen will automatically place the digsrc start opcode at the beginning of the resulting pattern
+when <code>:digsrc</code> overlay is used. In some cases (like when the pattern is used in a pattern set that has already started
+the instrument in a previous pattern, or possibly in svm_patterns) this behavior is undesirable.
+
+The insertion of this start opcode can be disabled by placing the following code **before** any overlay operations
+for a given pin.
+
+~~~ruby
+  tester.digsrc_skip_start :pin_or_group_name if tester.ultraflex?
+  # Overlay operations can happen after this point
+~~~
+
 % end

data/templates/origen_guides/program/charz.md.erb

@@ -0,0 +1,221 @@
+% render "layouts/guides.html" do
+
+Be sure to read and understand the guide to
+[Creating an Interface](<%= path "guides/program/interface" %>) before
+reading this guide.
+This guide covers aspects of the Characterization (charz) API. 
+
+Currently, the charz API has only been proven out for V93K SMT7, but isn't inherently designed around working only for that environment.
+
+The Charz API is enabled by including the Charz module in your interface:
+
+~~~ruby
+# app/lib/my_app/interface.rb
+module MyApp
+  class Interface
+    include OrigenTesters::ProgramGenerators
+    include OrigenTesters::Charz
+~~~
+
+Note this guide assumes the audience is familiar with interface creation and custom test methods, and will not go into detail explaining those topics.
+
+## Overview
+
+The Characterization API allows a flow to add characterization to existing production tests with little additional overhead.
+
+First specify charz routines to set charz test options, then create a profile with flow creation meta for the resulting tests.
+Afterwards, the `charz_on` method can be called in the flow to activate charz profiles, which is explained below.
+
+### Charz Routines
+
+Charz routines contain relevant charz data thats specific to a charz test to be created. Created routines are stored in the `@charz_routines` attribute.
+The data stored within a routine will be used in combination with the options used to make a production test to make a charz variant of the production test.
+
+The interface adds charz routines by calling the `add_charz_routine` method:
+
+~~~ruby
+add_charz_routine :vmin do |routine|
+  routine.name = 'cz_vmin_vdd'
+  routine.start = 1.0.V
+  routine.stop = 0.5.V
+  routine.res = 5.mV
+  routine.spec = 'VDD'
+end
+~~~
+
+### Charz Profiles
+
+Charz profiles contain a collection of routines, as well as test creation meta data related to test placement, production test result dependence, and conditional execution.
+
+The interface adds charz profiles by calling the `add_charz_profile` method. To create a profile that contains previously defined vmin and vmax search routines, whose resulting searches
+only run if the production test failed, and sets the vmax search routine to only run if the 'VmaxEnable' variable is set:
+
+~~~ruby
+add_charz_profile :fail_searches do |profile|
+  profile.name = 'fail_searches'
+  profile.on_result = :on_fail
+  profile.routines = [:vmin, :vmax]
+  profile.enables = { ['$VmaxEnable'] => [:vmax] }
+end
+~~~
+
+### Charz Session
+
+The charz session (stored in your interfaces `@charz_session` attribute) monitors the current state of characterization at a given point in flow generation.
+
+The API provides some key methods for querying that state during generation, such as:
+
+ * `charz_active?` : indicates if applicable productions tests should be generating charz tests as well
+ * `charz_only?`   : indicates if the production tests should be added to the flow or not, only generating the resulting charz test
+
+## Interface Considerations
+
+A couple of enhancements will need to be added to your interface to take advantage of the API in addition to adding `include OrigenTesters::Charz` as shown above.
+The charz routines and profiles will need to be added, and your flow methods will need to be updated to know what to do when a charz session is active.
+
+### Adding charz routines and profiles
+
+As long as the desired routines and profiles exist in the interface's @charz_routines and @charz_profiles hashes, the rest of the API will work as expected.
+One option is to add them during the interface initialization:
+
+~~~ruby
+# app/lib/my_app/interface.rb
+module MyApp
+  class Interface
+    include OrigenTesters::ProgramGenerators
+    include OrigenTesters::Charz
+
+    def add_charz
+      add_charz_routine :my_routine do |routine|
+        routine.name = 'cz_vmin_vdd'
+        routine.start = 1.0.V
+        routine.stop = 0.5.V
+        routine.res = 5.mV
+        routine.spec = 'VDD'
+      end
+      add_charz_profile :my_profile do |profile|
+        profile.name = 'vmin_search'
+        profile.routines = [:vmin]
+      end
+    end
+
+    def initialize(options = {})
+      add_charz
+    end
+~~~
+
+### Configuring Existing Flow Methods
+
+Now that your interface has defined some routines and profiles, the flow methods needs to be updated to work with an active charz session.
+
+Lets take a simplistic example functional flow method defined in `MyApp::Interface`:
+
+~~~ruby
+# V93K SMT7 example
+def func(name, options = {})
+  tm = test_methods.ac_tml.ac_test.functional_test
+  ts = test_suites.run(name, options)
+  ts.test_method = tm
+  ts.pattern = 'example'
+  flow.test ts, options
+end
+~~~
+
+And now we'll add the ability for this flow method to generate a charz test as well:
+
+~~~ruby
+# V93K SMT7 example
+def func(name, options = {})
+  if options[:routine]
+    tm = test_methods.ac_tml.ac_test.spec_search
+  else
+    tm = test_methods.ac_tml.ac_test.functional_test
+  end
+  ts = test_suites.run(name, options)
+  ts.test_method = tm
+  ts.pattern = 'example'
+
+  if options[:routine]
+    ts.spec = options[:routine].spec
+    ts.min = options[:routine].stop
+    ts.max = options[:routine].start
+    ts.resolution = options[:routine].res
+  end
+
+  flow.test ts, options
+
+  unless options[:charz_test]
+    insert_charz_tests(options.merge(parent_test_name: name, charz_test: true)) do |options|
+      charz_name = :"#{name}_#{charz_routines[options[:current_routine]].name}"
+      options[:routine] = charz_routines[options[:current_routine]]
+      func(charz_name, options)
+    end
+  end
+end
+~~~
+
+### #insert_charz_tests
+
+The `insert_charz_tests` method handles everything regarding adding the charz test into the flow except determining the actual name and parameters of the test, which is
+done by the local interface in the block passed to the `insert_charz_tests` method. This method handles:
+
+ * querying the charz session
+ * test placement
+ * charz test grouping
+ * production test result dependency
+ * gate processing (enables, flags) 
+
+The block that gets passed is yielded the latest options (with id removed if passed for the production test, so it doesn't get re-used for charz tests).
+Routines in the current session are yielded one at a time, with their id being returned in `options[:current_routine]`.
+
+#### Company Plugin Oppurtunity
+
+If your company is already using a plugin to distribute the definitions of these flow methods, this is a good oppurtunity to add charz variants of those methods
+that take routine as an input. This can really streamline the process, for example if you combine the charz flow methods plugin with a central flow entry point method called by
+all flow methods, then the implementation becomes:
+
+~~~ruby
+def add_to_flow(ts, options = {})
+  flow.test ts, options
+
+  unless options[:charz_test]
+    insert_charz_tests(options.merge(parent_test_name: name, charz_test: true)) do |options|
+      insert_current_charz_test(options)
+    end
+  end
+end
+~~~
+
+Where insert_current_charz_test is a method defined in the company charz flow method plugin.
+
+### Flow Usage Examples
+
+Now that the interface has charz routines and profiles, lets look at how to use the API within the flow itself:
+
+~~~ruby
+Flow.create(interface: 'MyApp:Interface') do
+
+  # regular non charz test
+  func :my_test1
+
+  # create charz test variants of my_test2 following the production
+  # version of my_test2 using the routines in :my_profile
+  charz_on :my_profile do
+    func :my_test2
+  end
+
+  # conditional charz enablement
+  # besides dut.enable_charz? check, identical to above
+  charz_on :my_profile if dut.enable_charz?
+  func :my_test3
+  charz_off if dut.enable_charz?
+
+  # override session values at the flow level
+  charz_on :my_profile, placement: :eof do
+    func :my_test4
+  end
+
+end
+~~~
+
+% end