origen_testers 0.19.0 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0f9e7b0562c602396e9cb070d57050486a854df
-  data.tar.gz: fbde57d2fa40beae37c0443261339bb2f8c187d7
+  metadata.gz: 3881d822046882174c8753d75a00c744a880799a
+  data.tar.gz: 8fac7fb32ad1c98a8111e162d71cb1e1ec44ea48
 SHA512:
-  metadata.gz: f58d90428732f2046cf98e8b0c175531fd1a150eb86c8771beb3e766b2ec2de483f7cd7f72d8b1d74d78edcf6c9ece7fe9a587f5945b38cb8be88e793c915e07
-  data.tar.gz: c87af16d5020f20bdae4abcc3b6227e21f2c33d87c5e9f2d156e9d452f53840153ff1ceb1043586a0d257ebe27c30ca29f02c37ee64853e1cddbca89a7c61c48
+  metadata.gz: f73357e78f88dc4957f46f32fc6f567c5725d8f0376ca5654ef37c04fefc82c54d9f66518a08964c04cbabb4c3869f8004e491a0151e791001fd5f86ddb43c73
+  data.tar.gz: c14255719d7077016fd21d8d23de5a6d0ee10179aaef18c7c0b4682ca37fdfacb3a50ebbab44f989e0caf14c928c3139638b2fde61c5e3c57df2ec4856887b49

data/config/application.rb

@@ -3,7 +3,40 @@ class OrigenTestersApplication < Origen::Application
   # for a full list of the configuration options available
 
   config.shared = {
-    :command_launcher => "config/shared_commands.rb"
+    command_launcher: "config/shared_commands.rb",
+    origen_guides: "templates/origen_guides",
+    origen_guides_index: -> (index) do
+      index.section :pattern, heading: "Pattern Generator", after: :controllers do |section|
+        section.page :introduction, heading: "Introduction"
+        section.page :creating, heading: "Creating Patterns"
+        section.page :pins, heading: "Pins"
+        section.page :timing, heading: "Timing and Waiting"
+        section.page :registers, heading: "Registers"
+        section.page :documenting, heading: "Documenting Patterns"
+        section.page :name, heading: "Generating by Name"
+        section.page :common, heading: "Common API"
+        section.page :j750, heading: "J750 API"
+        section.page :v93k, heading: "V93K API"
+        section.page :ultraflex, heading: "UltraFlex API"
+        section.page :custom, heading: "Custom Testers"
+        section.page :running, heading: "Running The PatGen"
+      end
+      index.section :program, heading: "Test Program Generator", after: :pattern do |section|
+        section.page :introduction, heading: "Introduction"
+        section.page :philosophy, heading: "Philosophy"
+        section.page :flows, heading: "Creating Flows"
+        section.page :flowapi, heading: "Managing Flow Control"
+        section.page :interface, heading: "Creating an Interface"
+        section.page :resources, heading: "Additional Resources"
+        section.page :code, heading: "Dynamic Custom Code"
+        section.page :j750, heading: "J750 API"
+        section.page :v93k, heading: "V93K API"
+        section.page :ultraflex, heading: "UltraFLEX API"
+        section.page :doc, heading: "Documenting the Program"
+        section.page :custom, heading: "Creating Custom Testers"
+        section.page :generating, heading: "Running the ProgGen"
+      end
+    end
   }
 
   # This information is used in headers and email templates, set it specific

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
   MINOR = 19
-  BUGFIX = 0
+  BUGFIX = 2
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/origen_testers/flow.rb

@@ -49,6 +49,7 @@ module OrigenTesters
     end
 
     def test(obj, options = {})
+      @_last_parameters_ = options.dup # Save for the interface's if_parameter_changed method
       obj.extract_atp_attributes(options) if obj.respond_to?(:extract_atp_attributes)
       super(obj, options)
     end

data/lib/origen_testers/interface.rb

@@ -55,6 +55,34 @@ module OrigenTesters
       OrigenTesters::Interface.write?
     end
 
+    # Returns true if the test flow context (as supplied in the given options)
+    # has changed vs. that applied to the previous test.
+    # Flow context means enabled words, job, if_failed/passed, etc.
+    def context_changed?(options = {})
+      flow.context_changed?(options)
+    end
+
+    # Returns true if the value of the given parameter within the given options is
+    # different vs. the last test
+    #   if parameter_changed?(:vdd, :vddc, options)
+    #     # execute code if the vdd level has changed
+    #   end
+    def parameter_changed?(*params)
+      options = params.last.is_a?(Hash) ? params.pop : {}
+      last = flow.instance_variable_get(:@_last_parameters_)
+      if last
+        params.any? { |p| options[p] != last[p] }
+      else
+        false
+      end
+    end
+
+    # Convenience method, equivalent of calling (context_changed? || parameter_changed?)
+    def context_or_parameter_changed?(*params)
+      options = params.last.is_a?(Hash) ? params.pop : {}
+      context_changed?(options) || parameter_changed?(*params, options)
+    end
+
     # Returns the value defined on if/how to make test names unique within a flow
     def unique_test_names
       @unique_test_names

data/lib/origen_testers/pattern_compilers/v93k.rb

@@ -313,7 +313,9 @@ module OrigenTesters
       def avc_digcap_vpf(contents)
         capture_vectors = 0
         contents.each_line do |line|
-          capture_vectors += 1 if /#{digcap.capture_string}/.match(line)
+          if line[0] != "\#"     # skip any comment lines
+            capture_vectors += 1 if /#{digcap.capture_string}/.match(line)
+          end
         end
         capture_vectors
       end

data/lib/origen_testers/smartest_based_tester/base.rb

@@ -147,16 +147,29 @@ module OrigenTesters
             when :subroutine, :default
               subroutine_overlay(overlay_str, options)
               ovly_style = :subroutine
+            when :handshake
+              if @delayed_handshake
+                if @delayed_handshake != overlay_str
+                  handshake
+                  @delayed_handshake = overlay_str
+                end
+              else
+                @delayed_handshake = overlay_str
+              end
             else
               ovly_style = overlay_style_warn(options[:overlay][:overlay_str], options)
           end # case ovly_style
         else
+          handshake if @delayed_handshake
+          @delayed_handshake = nil
           @overlay_subr = nil
         end # of handle overlay
 
         options_overlay = options.delete(:overlay) if options.key?(:overlay)
 
-        super(options) unless ovly_style == :subroutine
+        unless ovly_style == :subroutine || ovly_style == :handshake
+          super(options)
+        end
 
         unless options_overlay.nil?
           # stage = :body if ovly_style == :subroutine 		# always set stage back to body in case subr overlay was selected

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

@@ -18,16 +18,16 @@ module OrigenTesters
               output:    [:string, 'None', %w(None ReportUI ShowFailOnly)]
             },
             spec_search:                  {
-              max:             [:string, nil],
-              method:          [:string, nil],
-              min:             [:string, nil],
-              output:          [:string, 'None', %w(None ReportUI ShowFailOnly)],
-              resolution:      [:string, ''],
-              result_pin_list: [:string, ''],
-              setup_pin_list:  [:string, ''],
-              spec:            [:string, nil],
-              step:            [:string, nil],
-              test_name:       [:string, 'SpecSearch_Test']
+              max:            [:string, nil],
+              method:         [:string, nil],
+              min:            [:string, nil],
+              output:         [:string, 'None', %w(None ReportUI ShowFailOnly)],
+              resolution:     [:string, ''],
+              result_pinlist: [:string, ''],
+              setup_pinlist:  [:string, ''],
+              spec:           [:string, nil],
+              step:           [:string, nil],
+              test_name:      [:string, 'SpecSearch_Test']
             }
           }
 

data/lib/origen_testers/test/interface.rb

@@ -29,9 +29,11 @@ module OrigenTesters
         options = {
           duration: :static
         }.merge(options)
+        number = options[:number]
 
         if tester.j750? || tester.uflex?
           block_loop(name, options) do |block, i, group|
+            options[:number] = number + i if number && i
             ins = test_instances.functional(name)
             ins.set_wait_flags(:a) if options[:duration] == :dynamic
             ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
@@ -56,6 +58,7 @@ module OrigenTesters
 
         elsif tester.v93k?
           block_loop(name, options) do |block, i|
+            options[:number] = number + i if number && i
             tm = test_methods.ac_tml.ac_test.functional_test
             ts = test_suites.run(name, options)
             ts.test_method = tm

data/pattern/tester_overlay.rb

@@ -59,4 +59,15 @@ Pattern.create(name: "test_overlay") do
   tester.cycle inline_comment: '2nd line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
   tester.cycle inline_comment: '3rd line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
   tester.cycle repeat: 20
-end
+
+  if tester.v93k?
+    ss "Now kick the tires of handshake overlay"
+    tester.cycle repeat: 20
+    tester.overlay_style = :handshake
+    dut.pin(:pa).drive(5)
+    tester.cycle inline_comment: '1st line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
+    tester.cycle inline_comment: '2nd line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
+    tester.cycle inline_comment: '3rd line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
+    tester.cycle repeat: 20
+  end
+end

data/program/_erase.rb

@@ -19,7 +19,7 @@ Flow.create do |options|
 
   options[:pulses].times do |i|
     func :erase_all, number: number
-    number += i * 10
+    number += (i + 1) * 10
   end
 
   if options[:post_verify]

data/program/components/_prb1_main.rb

@@ -221,9 +221,9 @@ Flow.create do |options|
     bin 13, unless_enable: "AlarmEnabled"
   end
 
-  3.times do |k|
-    cc "cc test #{k}"
-    func "cc_test_#{k}".to_sym
+  3.times do |i|
+    cc "cc test #{i}"
+    func "cc_test_#{i}".to_sym, number: 7000 + i
   end
 
   pass 1, description: "Good die!", softbin: 1

data/program/test.rb

@@ -11,9 +11,9 @@ 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
+    func :program_ckbd, bin: 100, soft_bin: 1100, number: 40000
   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, lo_limit: 35, number: 40005
   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

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

@@ -0,0 +1,376 @@
+% render "layouts/guides.html" do
+
+All tester drivers support the common API described in this guide. By building your patterns
+using this API your will be able to generate them for any ATE that is supported by Origen.
+
+Some tester drivers may expose additional methods to leverage some key features of
+the given ATE which do not have direct equivalents on other systems. You may or may not
+choose to use these in your application. If you do, then be aware that you are introducing
+some logic which cannot be automatically translated to other ATEs. In that case you will have to implement
+the alternative implementation for other platforms on the application side,
+something like this:
+
+~~~ruby
+if $tester.uflex?
+  # An implementation that uses a method that only exists on the UltraFLEX driver,
+  # this will make the test run more efficiently on that platform
+else
+  # Conventional implementation using the common API for all other platforms
+end
+~~~
+
+Of course some applications may only ever wish to target a specific ATE, in that case you
+can freely pick from the common and ATE-specific APIs.
+
+This API is currently provided by the [Origen Testers plugin](http://origen-sdk.org/testers). In addition
+to the primary methods discussed below, all tester drivers support the methods described in the following
+API docs:
+
+* [OrigenTesters::VectorGenerator](http://origen-sdk.org/testers/api/OrigenTesters/VectorGenerator.html)
+* [OrigenTesters::Timing](http://origen-sdk.org/testers/api/OrigenTesters/Timing.html)
+* [OrigenTesters::API](http://origen-sdk.org/testers/api/OrigenTesters/API.html)
+
+### API Methods
+
+Here are each of the main methods supported by the common API.
+
+#### Generating Cycles
+
+These are the basic methods for generating vectors.
+
+##### cycle(options = {})
+
+Generate a tester cycle or cycles:
+
+~~~ruby
+$tester.cycle
+$tester.cycle repeat: 1000
+~~~
+
+As this is such a commonly used method, there are some convenience methods available, this is
+equivalent to the above example:
+
+~~~ruby
+1.cycle
+1000.cycles
+~~~
+
+A very common pattern when working at this level is to setup some pin states and
+then trigger a cycle:
+
+~~~ruby
+pin(:tdi).drive(1)
+$tester.cycle
+pin(:tdi).drive(0)
+$tester.cycle
+~~~
+
+All of the pin state methods support a bang (<code>!</code>) variant which will automatically
+call a single cycle after setting the pin state, this is equivalent to the above:
+
+~~~ruby
+pin(:tdi).drive!(1)
+pin(:tdi).drive!(0)
+~~~
+
+##### wait(options = {})
+
+Repeats the last vector for the specified about of time. The time can be specified in cycles
+or a time, multiple arguments will be added together:
+
+~~~ruby
+$tester.wait cycles: 1000         # Equivalent to $tester.cycle(repeat: 1000)
+$tester.wait time_in_us: 1000     # Wait for 1000us
+$tester.wait time_in_ms: 1        # Wait for 1ms
+
+$tester.wait time_in_ms: 1, time_in_us: 1000, cycles: 100     # Wait for 2ms + 100 cycles
+~~~
+
+The wait method can also be called with additional arguments to generate a dynamic wait,
+i.e. a match loop.
+Here for example to wait for up to 2 seconds for the done pin to go high:
+
+~~~ruby
+$tester.wait match: true, time_in_s: 2, pin: pin(:done), state: :high
+~~~
+
+The above API is somewhat verbose, a cleaner one is available by supplying a block to generate
+the vectors which much pass for the match to resolve.
+This is equivalent to the previous example:
+
+~~~ruby
+$tester.wait match: true, time_in_s: 2 do
+  pin(:done).assert!(1)
+end
+~~~
+
+This block form also allows much more complex match conditions to be described, here to wait
+for either the fail pin to go high, OR the done pin to go high:
+
+~~~ruby
+$tester.wait match: true, time_in_s: 2 do |conditions, fail|
+  conditions.add do
+    pin(:done).assert!(1)
+  end
+  conditions.add do
+    pin(:fail).assert!(1)
+  end
+end
+~~~
+
+To AND these conditions would simply be: 
+
+~~~ruby
+$tester.wait match: true, time_in_s: 2 do
+  pin(:done).assert(1)
+  pin(:fail).assert(1)
+  1.cycle
+end
+~~~
+
+##### ignore_fails(*pins)
+
+Ignore fails on the given pins for the duration of the given block, this
+has the effect of temporarily setting the states of the given pins to
+don't care.
+
+~~~ruby
+# Temporarily ignore mis-compares on the fail and data pins
+$tester.ignore_fails(pin(:fail), pins(:data)) do
+  # Any vectors generated in here will force the state of the given pins to X
+end
+~~~
+
+#### Data Capture
+
+##### store(*pins)
+
+Instruct the tester to capture the data on the given pins from the vector that was generated last,
+note that it does not actually generate a new vector.
+
+Sometimes when generating vectors within a loop you may want to retrospectively capture
+a previous vector, passing in an offset option will allow you to do this.
+
+Here are some examples:
+
+~~~ruby
+$tester.cycle                        # This is the vector that we want to capture
+$tester.store pin(:d0), pin(:d1)     # Capture the data on the d0 and d1 pins
+
+$tester.cycle                        # This one gets stored
+$tester.cycle
+$tester.cycle
+$tester.store pin(:d0), pin(:d1), offset: -2  # Just realized I need to capture that earlier vector
+~~~
+
+Note that this API is for engineers who are writing protocol drivers, most test IP would be
+written at a higher level, e.g.
+
+~~~ruby
+atd_result.data.store!   # Capture the value of the ATD result bits to the tester
+~~~
+
+##### store_next_cycle(*pins)
+
+Similar to the above, this API allows driver creators to indicate that the next vector,
+wherever that may be generated, should be captured:
+
+~~~ruby
+$tester.store_next_cycle pin(:d0), pin(:d1)
+
+# This is the vector that will be captured, in real life this could be done after returning
+# to a caller
+$tester.cycle  
+~~~
+
+##### capture_style
+
+Testers support different ways of capturing vector data.  For all tester types the default
+capture style is hram (history ram).  For UltraFlex digcap is additionally supported.  Change
+from the default like this:
+
+~~~ruby
+# change capture style
+# if the digcap isn't support for the current tester, default behavior (hram) is used
+tester.capture_style = :digcap
+
+# change back to hram capture style
+tester.capture_style = :hram
+
+# temporarily change the capture style for this cycle
+tester.store_next_cycle pin(:d0), capture_style: :digcap
+~~~
+
+##### configure capture memory
+
+Origen will create any instrument definitions required when capture memory is used.  However,
+it may be desirable to alter the configuration settings.  Here is an example of how to do this:
+
+~~~ruby
+# configure TDO as a 16-bit instrument (default size is the number of pins - 1 in this case)
+tester.capture_memory :digcap do |mem|
+  mem.pin :tdo, size: 16
+end
+~~~
+
+#### Data Source
+
+##### overlay
+Testers support different ways of modifying vector data during run time.  This practice is referred to
+here as "overlay".  Overlay is requested through an optional argument to cycle:
+
+~~~ruby
+# setup overlay parameters
+overlay_options = {}
+# Required - what pin(s) are being overlayed?
+overlay_options[:pins] = dut.pin(:tdi)
+# Required - what is the overlay string? This will become a label or subroutine name
+overlay_options[:overlay_str] = ovl_reg[i].overlay_str
+
+tester.cycle overlay: overlay_options
+
+# Generate another overlay cycle, holding the same data as the previous cycle
+overlay_options[:change_data] = false
+tester.cycle overlay: overlay_options
+
+# Now a new piece of data needs to be sent
+overlay_options[:change_data] = true
+tester.cycle overlay: overlay_options
+~~~
+
+##### overlay_style
+
+The default overlay style is subroutine (vectors that will be modified are replaced
+by a call to a subroutine).  Change from the default like this:
+
+~~~ruby
+# if requested sytle is not available for the current tester it will default to :subroutine
+tester.overlay_style = :digsrc
+tester.overlay_style = :subroutine
+tester.overlay_style = :label
+tester.overlay_style = :handshake
+
+# change the overlay style for this cycle only by adding :overlay_style to the overlay_options
+overlay_options[:overlay_style] = :label
+tester.cycle overlay: overlay_options
+~~~
+
+Not all overlay styles are supported on all testers and if the requested style is not supported a warning
+will be logged and it will fall back to the default style (:subroutine).
+
+Here is a brief summary of what each type does:
+
+digsrc
+: The vectors to be modified are updated with the data value held in a tester memory.
+
+subroutine
+: The vectors to be modified are removed from the pattern and replaced by a call to a another (subroutine) pattern.
+
+label
+: A label is inserted into the pattern immediately before the vectors to be modified.
+
+handshake
+: The vectors to be modified are removed from the pattern and replaced by a handshake with the tester.
+
+
+##### configure source memory
+
+Origen will create any necessary instruments statements.  Add configuration information to source memory
+like this:
+
+~~~ruby
+tester.source_memory do |mem|
+  mem.pin :tdi, size: 32, format: :binary, data_type: :long
+end
+~~~
+
+#### Subroutines
+
+##### start_subroutine(name), end_subroutine
+
+Use these methods to write a pattern subroutine:
+
+~~~ruby
+$tester.start_subroutine "wait_for_done"
+$tester.wait match: true, time_in_s: 2 do
+  pin(:done).assert!(1)
+end
+$tester.end_subroutine
+~~~
+
+##### call_subroutine(name, options = {})
+
+Call a pattern subroutine, an offset can be given to retrospectively jump to a subroutine
+from a previous vector:
+
+~~~ruby
+$tester.call_subroutine "wait_for_done"
+1.cycle
+1.cycle    #  A branch will also be made after completing this vector
+1.cycle
+1.cycle
+$tester.call_subroutine "wait_for_done", offset: -2
+~~~
+
+#### Loops and Branching
+
+##### label(name)
+
+Inject an arbitrary label into the pattern:
+
+~~~ruby
+$tester.label "on_failed"
+~~~
+
+##### branch_to(label)
+
+Branch to a label:
+
+~~~ruby
+$tester.branch_to "on_failed"
+~~~
+
+##### loop_vectors(name, number_of_loops)
+
+Execute the vectors generated within the given block *n* times:
+
+~~~ruby
+$tester.loop_vectors("my_loop", 3) do   # Do this 3 times...
+  $tester.cycle
+end
+~~~
+
+#### Miscellaneous
+
+##### freq_count(pin)
+
+Setup to measure the frequency on the given pin:
+
+~~~ruby
+$tester.freq_count pin(:clk_out)
+~~~
+
+##### microcode(code, options = {})
+
+This can be used to inject arbitrary microcode into the pattern, which of course is
+inherently coupling your logic to a specific test platform - so use sparingly!
+
+An offset can be given to apply the microcode to previously generated vectors.
+
+~~~ruby
+$tester.microcode 'set_cpu (cpuC)'
+1.cycle
+1.cycle    # cpuB will be set here 
+1.cycle
+1.cycle
+$tester.microcode 'set_cpu (cpuB)', offset: -2
+~~~
+
+##### Free-Running Clock on Existing Pin
+
+Set up a pin to be a free-running clock with the vector generation (with respect to toggling
+the pin at the appropriate intervals) automatically taken care of.
+
+See [Pin Clock Functionality](<%= path 'guides/models/pins/#Pin_Clock_Functionality' %>) for details on the API.
+
+% end