Tag: v0.45.2

Branch: ‘master’
by info-rchitect on 24-Feb-2020 10:34AM
  • Inhibit vectors bug fixes
  • nil flag check error handling
  • Match loop bug fixes
  • Removed testing for Ruby 2.3

Tag: v0.45.1

Branch: ‘master’
by Stephen McGinty on 28-Jan-2020 12:26PM

Fix V93K capture vector counting when loops are involved (TS Chung)

Tag: v0.45.0

Branch: ‘master’
by info-rchitect on 15-Jan-2020 10:48AM
  • Added support for naming sub-flows
import :my_sub_flow, name: 'new_sub_flow_name'

Tag: v0.44.1

Branch: ‘master’
by Stephen McGinty on 19-Dec-2019 02:28AM

Fixed V93K subroutine pattern generation

Tag: v0.44.0

Branch: ‘master’
by Priyavadan Kumar on 05-Dec-2019 11:21AM

Enabled Bypass option on the 93K

Tag: v0.43.0

Branch: ‘master’
by Daniel Hadad on 11-Nov-2019 14:23PM

Allow import of top-level flow during test program generation.

Tag: v0.42.0

Branch: ‘master’
by Corey Engelken on 08-Sep-2019 13:16PM

Added decompilation support and updated timesets for better syncing between the tester and the dut instances. See the guides for details on both.

Tag: v0.41.0

Branch: ‘master’
by info-rchitect on 16-Aug-2019 11:27AM
  • PR#134: Make target reload optional during flow generation
  • PR#133: Add support for the V93K force_serial test method parameter
  • PR#129: Make rendering limits in V93K flow file optional at the test method library level
  • PR#132: Ensure flow variable flags of mixed types are allowed
  • PR#131: Bug fix for V83K flow generation if no local flags present
  • PR#125: New feature, when* conditional statements for V93K flow generation
  • PR#130: New feature, if_any_site and if_all_sites control options for IG-XL flow generation

Tag: v0.40.0

Branch: ‘master’
by Stephen McGinty on 24-Jul-2019 02:40AM

Added support for V93K SMT8

Tag: v0.31.0

Branch: ‘master’
by Stephen McGinty on 26-Jun-2019 06:40AM

Added support for attributes to be defined as boolean types in V93K custom test method definitions

Tag: v0.30.0

Branch: ‘master’
by Stephen McGinty on 20-Jun-2019 03:21AM

Incorporated ATP gem into OrigenTesters

Tag: v0.21.0

Branch: ‘master’
by Paul DeRouen on 23-May-2019 08:27AM
  • Pattern conversion support (global convert command added)
origen convert path/to/my_pattern.stil -e v93k_smt7

When run outside an app an annonymous DUT is created. The environment option defines the output currently j750, uflex and v93k_smt7. The only input format supported is STIL. Other input formats will be supported in the future.

  • Add STIL tester OrigenTesters::STIL.new<\code>

  • Add multi-limit with unique TName support for UFlex program generation

  functional :test2, sbin: 101, number: 20020,
    sub_tests: [
      sub_test(:limit_name1, lo: -2, hi: 2),
      sub_test(:limit_name2, lo: -1, hi: 1)
    ]
  • Add hooks required for concurrent pattern generation documented here

Tag: v0.20.0

Branch: ‘master’
by Ronnie Lajaunie on 06-Feb-2019 10:15AM

–Add support for flow description for 93K (PR #105)

Examples:
Ex1.
Flow.create interface: 'MyInterface' do
  flow.flow_name = 'SETUP'
  flow.flow_description = 'Setup Variables and Guardbands'

  test :setup_test, cont: true
end

renders:

-----------------------------------------------------------------
test_flow

  {
    run(setup_test);

  }, open,"SETUP","Set Variables and Guardbands"

end
-----------------------------------------------------------------
Ex2.
Flow.create interface: 'MyInterface', flow_name: 'SETUP', flow_description: 'Setup Variables and Guardbands' do

  test :setup_test, cont: true

end

renders:

test_flow

  {
    run(setup_test);

  }, open,"SETUP","Set Variables and Guardbands"

end
Ex3.
# Comments about this flow
Flow.create interface: 'MyInterface', flow_name: 'SETUP' do

  test :setup_test, cont: true

end

renders:

test_flow

  {
    run(setup_test);

  }, open,"SETUP","Comments about this flow"

end

–Testflow indention spacing to match formatted .tf files that are save from SmartTest GUI (PR #107)

–Removal of testmethodlimits, testmethods, or test_suites sections if they are empty (follows ST GUI-saved format) (PR #107)

–Support not_over_on bin flag control using bin_attrs (PR # 108)

Example:
func :test1n, number: 51960, bin: 12, bin_attrs: { not_over_on: true }

renders:

  run_and_branch(test1n)
  then
  {
  }
  else
  {
    stop_bin "", "fail", , bad, noreprobe, red, 12, not_over_on;
  }

–Add method to Flow class that allows interface access to the ‘description’ stack (aka cc and ht comments). Main use case is to use as ‘comment’ text assigned to test suite. (PR #110)

Example:

flow file:

# The is auto-generated comment from hasttag
func_with_comment :test1

cc 'The is auto-generated comment from cc'
func_with_comment :test2

interface:

def func_with_comment(name, options = {})
  tm = test_methods.ac_tml.ac_test.functional_test
  ts = test_suites.run(name, options)
  ts.test_method = tm
  ts.levels = options.delete(:pin_levels) if options[:pin_levels]
  ts.comment = options.delete(:comment) || flow.active_description
  flow.test ts, options
end

renders tf:

test1:
  comment = "The is auto-generated comment from hasttag";
  local_flags = output_on_pass, output_on_fail, value_on_pass, value_on_fail,
per_pin_on_pass, per_pin_on_fail;
  override = 1;
  override_seqlbl = "test1";
  override_testf = tm_1;
  site_control = "parallel:";
  site_match = 2;

test2:
  comment = "The is auto-generated comment from cc";
  local_flags = output_on_pass, output_on_fail, value_on_pass, value_on_fail,
per_pin_on_pass, per_pin_on_fail;
  override = 1;
  override_seqlbl = "test2";
  override_testf = tm_2;
  site_control = "parallel:";
  site_match = 2;

Tag: v0.19.3

Branch: ‘master’
by Ronnie Lajaunie on 16-Oct-2018 09:15AM
  • Create output_directory for pattern_compiler if necessary PR 103

Tag: v0.19.2

Branch: ‘master’
by Ronnie Lajaunie on 03-Oct-2018 10:22AM
  • Re-try push to rubygems.org

Tag: v0.19.1

Branch: ‘master’
by Ronnie Lajaunie on 02-Oct-2018 06:43AM

*Bug fix to ignore compare characters in comment lines (RE: V93k Digcap)

Tag: v0.19.0

Branch: ‘master’
by Daniel Hadad on 02-May-2018 09:04AM

Added additional v93k capability including:

Tag: v0.18.0

Branch: ‘master’
by Stephen McGinty on 03-Apr-2018 11:38AM
  • cc style comments are now supported in test flow files to enable dynamic comments to be created for documentation (Code Briscoe)

    # Regular Ruby comments can still be used to provide static documentation of tests
    # in a test program flow file
    test :my_test
    
    cc "The cc method can be used to create comments that contain dynamic data: #{4 + 4}"
    test :my_test
    
    # This is expected to be most useful when generating tests in a loop:
    
    [:min, :nom, :max].each do |vdd|
      cc "Test something at #{vdd} vdd"
      test :my_test
    end
    
  • The test name for the main limits in a V93K test method can be set by a limits_id attribute instead of test_name. When limits_id is used it will set the name of the limits but will not appear in the test methods attribute list (unlike test_name which will). (Brian Caquelin)

Tag: v0.17.0

Branch: ‘master’
by Stephen McGinty on 28-Mar-2018 09:40AM
  • Added definition for ac_tml.AcTest.SpecSearch test method (Ronnie Lajaunie)
  • Added source/capture count comment in PXIE tester patterns (Paul Derouen)
  • Fix for bug introduced in 0.16.1 whereby tester.set_timeset did not update the corresponding DUT timing attributes

Tag: v0.16.1

Branch: ‘master’
by Stephen McGinty on 14-Feb-2018 11:18AM

Now warns instead of crashing in the case where set_timeset is called before instantiating the DUT. This was allowed in previous versions OrigenTesters and improves backwards compatibility.

Tag: v0.16.0

Branch: ‘master’
by Stephen McGinty on 31-Jan-2018 17:01PM
  • PXI pattern generator improvements (Paul Derouen)
  • Added flag declaration (defaults line) for generated AND (and OR) flags in IG-XL
  • Supports latest ATP flow API (1.1)

Tag: v0.15.0

Branch: ‘master’
by Lajaunie Ronald-B01784 on 27-Nov-2017 10:20AM

Extend existing PatternCompilers to include J750 and V93K Platforms (RP #69)

Paths to compiler tools are now picked up as Origen site configs
# origen_site_config.yml
origen_testers:
  :v93k_linux_pattern_compiler: '/path/to/v93k/tool/set'
  :j750_windows_pattern_compiler: '/path/to/j750/compiler'
UltraFLEX Compiler

Moved some code around to be shared with J750 compiler enablement, but functionally works the same as before.

# inside of dut class
      @ultraflex_compiler_options = {
        path: "#{Origen.root}/spec/patterns/atp/functional",
        clean: true,
        location: :local,
        recursive: false,
        output_directory: "#{Origen.root}/spec/patterns/bin",
        opcode_mode: 'single',
        comments: false,
        verbose: true
      }
#

dut.add_pattern_compiler(:id1, :ultraflex, dut.ultraflex_compiler_options)
J750 Pattern Compiler

Works pretty much same as UltraFLEX, of course with J750-specific options and it’s own, unique toolset path.

# inside of dut class
      @j750_compiler_options = {
        path: "#{Origen.root}/spec/patterns/atp/j750",
        clean: true,
        location: :local,
        recursive: false,
        output_directory: "#{Origen.root}/spec/patterns/bin/j750",
        pinmap_workbook: "#{Origen.root}/spec/patterns/atp/bist/bist_pins.txt",
        opcode_mode: 'single',
        comments: false
      }
#

dut.add_pattern_compiler(:id2, :j750, dut.j750_compiler_options)
V93K Supports:
  • On-the-fly generation of aiv configuration file based on pattern compiler options (can specify compiler instance, or use default).
  • Multiport burst enablement with pattern compiler options; both single port and multiple port cases are handled
  • Digital Capture Settings auto-inserted into aiv (pre-compile) based on ‘digcap’ pattern compiler options
  • Given exisiting aiv and workspace setup, can run stand-alone outside of pattern generation (e.g. during program generation/module builds)
# inside of dut class
      @v93k_compiler_options = {
        config_dir: "#{Origen.root}/spec/patterns",
        pinconfig: "compiler_pins.cfg",
        tmf: "timing_map_file.tmf",
        multiport: {
          port_bursts: {
            p_1: 'pattern_burst_1',
            p_2: 'pat_burst_two'
          },
          port_in_focus: 'p_FOCUS',
          prefix: 'mpb'
        },
        digcap: {
          pins: :porta,
          vps: 1,
          nrf: 1,
        },
      }
#

dut.add_pattern_compiler(:id3, :v93k, dut.v93k_compiler_options)

Tag: v0.14.0

Branch: ‘volatile_flags’
by Stephen McGinty on 20-Nov-2017 13:29PM
  • Improvements to the generated SmarTest output to align it more closely to how SmarTest creates the flow files when they are saved - Ronnie Lajaunie
  • Added pattern generation support for the NI pcie6570 tester - Paul Derouen
  • Significant internal changes to align with the abstract test program model and API provided by ATP v1
  • Various other minor improvements and bug fixes

Tag: v0.13.2

Branch: ‘master’
by FSL\b04525 on 18-Oct-2017 09:19AM

fixed label overlay behavior for IGXL testers V93K flow enhancements

Tag: v0.13.1

Branch: ‘master’
by Daniel Hadad on 03-Oct-2017 09:09AM

Provide accessor to min_repeat_loop so user can change if desired.

Tag: v0.13.0

Branch: ‘master’
by Stephen McGinty on 26-Sep-2017 15:08PM

This release contains significant optimization of the V93K test flow output, making better use of the available if/else branching constructs and eliminating the use of many runtime flags/variables.

Significant additional test coverage has been added to origen_testers to verify this and the output has been reviewed on at least 3 independent Origen applications, so the chances of a bug hitting an application is low. However, users are advised to review the changes that this release makes to their flow output to be sure.

Additional changes included in this release:

  • Fix to how mixed case flags (added in 0.12.0) are handled in the variables file (Adam Kohler)
  • Calling tester.set_timeset will now automatically update the DUT timing period referenced by the Origen timing API (Paul Derouen)

Tag: v0.12.0

Branch: ‘master’
by Stephen McGinty on 19-Sep-2017 20:46PM

Added support for mixed-case flag references (arkohler)

Tag: v0.11.1

Branch: ‘master’
by Stephen McGinty on 15-Sep-2017 22:10PM

Patch to apply any in-line flow conditions passed to render

Tag: v0.11.0

Branch: ‘master’
by Stephen McGinty on 15-Sep-2017 21:36PM
  • Handle spaces in V93K custom test method attribute names (John Black)
  • Apply flow conditions to V93K flow render snippets

Tag: v0.10.0

Branch: ‘master’
by pderouen on 06-Sep-2017 08:42AM

tester handled overlay added 93k flow generation updated

Tag: v0.9.9

Branch: ‘master’
by Stephen McGinty on 28-Aug-2017 15:52PM

Added V93K flow enable word feature, see: https://origen-sdk.org/origen/guides/program/v93k/#Flow_Considerations

Tag: v0.9.8

Branch: ‘master’
by Daniel Hadad on 04-Aug-2017 12:09PM

Added bitmap testcase for keep_alive capability. Fixed type on J750 side.

Tag: v0.9.7

Branch: ‘master’
by Daniel Hadad on 03-Aug-2017 13:15PM

Added capability for UltraFLEX to support pattern keep alive using keep_alive subroutine. Updated 2pin match capability to support custom jump label usage.

Tag: v0.9.6

Branch: ‘master’
by Stephen McGinty on 09-May-2017 13:54PM

Bug fix for V93K test program generation - flow control vars are now initialized correctly upon each flow execution, whereas previously the value from one run would carry over into the next.

Tag: v0.9.5

Branch: ‘master’
by Lajaunie Ronald-B01784 on 31-Mar-2017 13:22PM

Added support for utility pins for functional test on J750 tester. #

Tag: v0.9.4

Branch: ‘master’
by Lajaunie Ronald-B01784 on 27-Mar-2017 21:47PM
  • Add support for pin.clock duty_cycle API

Tag: v0.9.3

Branch: ‘master’
by Ronnie Lajaunie on 07-Mar-2017 10:21AM
  • Add V93K-specific AST processor chain to optimize test flow before final rendering. More specifically, it removes replaces empty run_and_branch with run. It replaces any one-use, auto-generated flags with the run-test with the same condition.

Tag: v0.9.2

Branch: ‘master’
by Daniel Hadad on 28-Feb-2017 15:31PM

Added capability for UFLEX pattern generation to be able to have subroutines contained in their own module. This permits pattern sequencer on tester to swap the subroutines in and out. Closes issue #31.

Tag: v0.9.1

Branch: ‘master’
by Ronnie Lajaunie on 22-Feb-2017 08:57AM
  • Add support for new functionality of atp gem for bin descriptions.

Tag: v0.9.0

Branch: ‘master’
by Stephen McGinty on 09-Feb-2017 04:01AM

flow.render is now supported for V93K

Tag: v0.8.13

Branch: ‘master’
by Chris Nappi on 24-Jan-2017 15:20PM

93K Test numbers

Tag: v0.8.12

Branch: ‘master’
by Ronnie Lajaunie on 24-Jan-2017 15:05PM
  • Add test number to testlimit section of tf template.

Tag: v0.8.11

Branch: ‘master’
by Chris Nappi on 13-Jan-2017 11:34AM

More flexible V93K testmethod naming

Tag: v0.8.10

Branch: ‘master’
by Ronnie Lajaunie on 11-Jan-2017 09:48AM

Gem server path update to fix unsuccessful release issue.

Tag: v0.8.9

Branch: ‘master’
by Ronnie Lajaunie on 11-Jan-2017 09:37AM
  • Add functionality to alow for formatting of testmethodparamter names as first-letter-upper-case-camel-case. To use, set the first character in the parameter name (in the add_tml method) to ‘_’.
  Origen.interface.add_tml :new_method,
                           class_name: 'MCLASS',

                           set_and_check_fuses: {
                             class_name:          'MCLASS.MethodDescription',
                             _param_one:          [:string, nil],
                             _param_two:          [:string, nil],
                             param_three:         [:string, nil],
                             param_four:          [:string, nil],
                           }

Generates:

 testmethodparameters
tm_1:
  "ParamOne" = "";
  "ParamTwo" = "";
  "paramThree" = "";
  "paramFour" = "";

Tag: v0.8.8

Branch: ‘master’
by Stephen McGinty on 13-Dec-2016 11:23AM

Patch to allow the flow control methods, e.g. if_job, to be be overridden by an interface.

Also cleaned up the development environment a lot, to align the way that targets, environments and interface are handled with the latest best practices.

Tag: v0.8.7

Branch: ‘master’
by Stephen McGinty on 08-Dec-2016 10:35AM

Clean up to how inline comments are handled on V93K which should fix the following issues:

  • The Origen diff tracker now ignores diffs in inline comments
  • Microcode is no longer included in the inline comments
  • Spacing/vertical alignment between multi-line comments is now preserved
  • Repeat numbers always appear at the start of the comment for better viewing
  • Removed trailing and superfluous carriage returns, tkdiff seems to handle these patterns properly now

Inline comments can now be disabled from your environment setup file like this:

tester.inline_comments = false

Tag: v0.8.6

Branch: ‘master’
by Chris Nappi on 21-Oct-2016 08:57AM

Minor changes to 93K, change min repeat to 33 and cut comments at 250 chars

Tag: v0.8.5

Branch: ‘master’
by Stephen McGinty on 06-Oct-2016 07:58AM

Minor patch to prevent a runtime error if pattern = nil or false is ever called on a 93K test suite object.

Tag: v0.8.4

Branch: ‘master’
by Stephen McGinty on 19-Sep-2016 10:45AM

Added meta attribute to test instance and test suite objects. If present, this will be included in test flow documentation.

# Generate a test instance/method
if tester.j750?
  i = test_instances.functional(name, options)
elsif tester.v93k?
  i = test_suites.add(name, options)
  i.test_method = origen.functional_test
end
i.pattern = "rambist_march"

# Add meta data
i.meta = {
  "Test" => i.name,        # 'Test' and 'Pattern' will be used in documentation
  "Pattern" => i.pattern,  # to name the tests, all other attrs will simply
  "Vdd" => vdd,            # be output verbatim
  "Cycles" => cycles
}

# Insert test into flow as normal
flow.test(i, options)

Tag: v0.8.3

Branch: ‘master’
by Chris Nappi on 14-Sep-2016 08:56AM

fix missed pull request

Tag: v0.8.1

Branch: ‘master’
by Stephen McGinty on 13-Sep-2016 08:37AM

Bugfix - Previously only the first test method object in a V93K test program had it’s finalize method called (if defined). Now they are all called.

Tag: v0.8.0

Branch: ‘master’
by Stephen McGinty on 13-Sep-2016 02:51AM

Re-tagging as 0.8.0

Tag: v0.8.0.pre1

Branch: ‘master’
by Chris Nappi on 12-Sep-2016 12:51PM

Include header comments in-line with embedded ‘ctrl-m’ so they are visible in gui Move comments before ‘;’ so they translate into binl

Tag: v0.7.13

Branch: ‘master’
by Stephen McGinty on 09-Sep-2016 06:18AM

Patch to allow interfaces to include Origen::Callbacks

Tag: v0.7.12

Branch: ‘master’
by Stephen McGinty on 22-Aug-2016 11:01AM

Standardized the boot order of this plugin, fixes warnings in Origen 0.7.24 onwards

Tag: v0.7.11

Branch: ‘master’
by Stephen McGinty on 19-Aug-2016 07:01AM

Fixes for Github issues #10 and #20

Tag: v0.7.10

Branch: ‘master’
by Stephen McGinty on 17-Aug-2016 06:57AM

Added a variables file to the V93K program generator output (output to OUTPUT/testflow/mfh.testflow.setup/).

By default this is a global file but it can be made flow specific by setting resources_filename as per other file generators.

Tag: v0.7.9

Branch: ‘master’
by Stephen McGinty on 15-Aug-2016 06:16AM
  • Bugfix to J750 pattern output to setup freq_count after the opcode has been defined (Thao Huynh)
  • Turned off timestamps in the pattern comments by default due to it causing too many diffs when reviewing changes. It will now be enabled with the -v option which already enabled vectors and cycle count comments.

Tag: v0.7.8

Branch: ‘master’
by Stephen McGinty on 12-Aug-2016 12:15PM

Various updates for V93K, this release puts the support for V93K on a par with that for J750 and UltraFLEX.

  • The list/referenced.list file output from the program generator is now diff tracked
  • Added ability to specify a custom test method attribute’s type as being the inverse of another attribute, e.g.
my_test_method:       {
  force_mode:  [:string, 'VOLT', %w(VOLT CURR)],
  force_value: [:force_mode, 3800.mV],   # Type will be :voltage when force_mode set to 'VOLT'
  spmu_clamp:  [:force_modeb, 0]         # Type will be :current when force_mode set to 'VOLT'
}
  • Changed the output directory/filename of flow files to align to the MFH (master file handler) conventions
  • Pattern master (.pmfl) and compiler (.aiv) files now default to a file called global and will contain all references for a given generator run, this is equivalent to how pattern/instance sheets are handled for Teradyne. The app can change this on a per-flow basis by setting the interface’s resources_filename attribute, again same as Teradyne sheets.
  • Better naming of multi-part patterns. _part1, _part2, etc. is now appended after the app’s pattern postfix, this generally makes app-level pattern references easier to handle.
  • On V93K there is sometimes the situation where you want the test program to have a reference to a pattern (in the .pmfl), but you don’t want it in Origen’s list/referenced.list, and vice versa. The API for adding a pattern reference from the app has been improved to support this:
# From the app's test program interface...

# The original API is still supported, this will add a reference to
# list/referenced.list and the .pmfl (and .aiv)
referenced_patterns << "some_pattern"

# This is equivalent with the new API
record_pattern_reference("some_pattern")

# V93K needs to know if the reference is to a subroutine, this can be
# indicated like this
record_pattern_reference("some_pattern", subroutine: true)

# To make the reference appear in Origen's list/referenced.list only
record_pattern_reference("some_pattern", type: :origen)

# To make the reference appear in the .pmfl (and .aiv) only
record_pattern_reference("some_pattern", type: :ate)
  • Finally there are various minor bug fixes

Tag: v0.7.7

Branch: ‘master’
by Stephen McGinty on 09-Aug-2016 12:48PM

Added a timestamp to all major step comments, useful when looking at a pattern in simulation.

Bug fix for flow.render when called from a plugin via a top-level app.

Tag: v0.7.6

Branch: ‘master’
by Stephen McGinty on 27-Jul-2016 08:49AM

Fixed some syntax bugs in V93K flow output

Tag: v0.7.5

Branch: ‘master’
by Priyavadan Kumar on 01-Jul-2016 15:05PM

Updates from Thao

Tag: v0.7.4

Branch: ‘master’
by Priyavadan Kumar on 16-Jun-2016 13:15PM

Added Frequency Counter support for UltraFLEX.

Tag: v0.7.3

Branch: ‘master’
by Ronnie Lajaunie on 15-Jun-2016 09:33AM

Minor update to smartest_based_tester to allow for lower-case naming of pin groups of size 1 (or more).

Tag: v0.7.2

Branch: ‘master’
by Stephen McGinty on 09-Jun-2016 09:40AM
  • Corrected formatting bug in (UltraFLEX) Levelset sheet creation (Aaron Burgmeier)
  • Added a hook to allow 3rd party plugins that provide a tester driver, to easily make their program generator API available to their user’s interface:
# Application interface
module MyApp
  class Interface
    # All interfaces should include this, adds the program generator APIs for all
    # platforms supported by OrigenTesters, and now also any platforms provided
    # by 3rd parties
    include OrigenTesters::ProgramGenerators
  end
end

# 3rd Party Plugin, this is the class that will be instantiated in the target/environment
module MyTester
 class Tester
   # By defining this constant OrigenTesters will load the API into the interface
   # whenever an instance of this class is the current tester loaded by the target 
   TEST_PROGRAM_GENERATOR = MyTester::Generator
  end
end

# 3rd Party Plugin, this implements the program generator API
module MyTester
  class Generator
    extend ActiveSupport::Concern

    included do
      include OrigenTesters::Interface  # adds the interface helpers/Origen hook-up
    end

    # This method will now be available within the above application interface
    def some_api_method
      # Generator some test program item
    end
  end
end

Tag: v0.7.1

Branch: ‘master’
by Priyavadan Kumar on 27-May-2016 13:44PM

Updates to the UltraFLEX Interface to support a few extra features that were previously not included.

Tag: v0.7.0

Branch: ‘master’
by Stephen McGinty on 23-May-2016 03:22AM

Fixed bug from additional capture cycles being inserted into period levelled vector on V93K, now works correctly like this:

$tester.set_timeset("fast", 40)
2.cycles                        #    fast   1 0 C 1 0
                                #    fast   1 0 C 1 0

$tester.level_period = false  # Without levelling enabled
$tester.set_timeset("slow", 80)
2.cycles                        #    slow   1 0 C 1 0
                                #    slow   1 0 C 1 0

$tester.level_period = true   # With levelling enabled
$tester.set_timeset("slow", 80)
2.cycles                        #    fast   1 0 X 1 0
                                #    fast   1 0 C 1 0
                                #    fast   1 0 X 1 0
                                #    fast   1 0 C 1 0

Tag: v0.7.0.pre0

Branch: ‘master’
by Chris Nappi on 04-May-2016 10:59AM

Added check for size in header case change Patch for operation on Windows Corrected ‘GlobalSpecs’ output file for examples check 93K - Allow pingroups and aliases to have lower case letters Updated sheet prefix for Global Specs Added UFlex sheet generation support for Timeset Basic, Global Specs,…

Tag: v0.6.2

Branch: ‘master’
by Stephen McGinty on 08-Apr-2016 09:02AM

Minor patch to create the test program output directory if it doesn’t exist

Tag: v0.6.1

Branch: ‘master’
by Stephen McGinty on 31-Mar-2016 07:36AM

Added link? method to the common API (i.e. available on all tester objects) to check if the current tester is an OrigenLink driver

Tag: v0.6.0

Branch: ‘master’
by Stephen McGinty on 23-Mar-2016 12:57PM

Some major feature additions:

Completely overhauled test flow generator backend, which now fully supports the same test flow source code rendering to J750, UltraFLEX and V93K.

Official documentation for this is still to follow, but for now see the comments in the pull-request for some examples: PR #3

Added generator APIs for UltraFLEX pinmaps, edgesets, timesets, levelsets, and AC and DC spec sets (Aaron Burgmeier).

Again the documentation is still to come, but examples of using these APIs can be found in lib/origen_testers/test/ultraflex_interface.rb

Tag: v0.5.7

Branch: ‘master’
by Stephen McGinty on 08-Mar-2016 06:54AM
  • Added ATE_Hardware Code and related syntatic sugar code for Origen Core #7 (Scott Chen)
    • Minor Updates for Import_chanmap method.
    • Added ATEHardware Class for PPMU/Supply spec look-up for Test Program Generation.
# Importing UltraFLEX tester config
$tester.import_tester_config('FT', "#{Origen.root}/spec/atehardware/CurrentConfig_sample.txt")
$tester.default_testerconfig                # => 'FT'
$tester.get_tester_instrument('FT', 1)      # => 'HSD-4G'
$tester.get_instrument_slots('FT', 'HSD-U') # => [12, 14, 15, 17, 20]

# Importing UltraFLEX channel map
$tester.import_chanmap('FTx4', "#{Origen.root}/spec/atehardware/atehardware_chanmap.txt")
$tester.default_channelmap                      # => 'FTx4'
$tester.get_tester_channel('FTx4', :pin1, 0)    # => '14.ch28'
$tester.get_tester_channel('FTx4', :pin2, 3)    # => '20.ch231'
$tester.channelmap['FTx4'].size                 # => 4
$tester.merged_channels('FTx4', :avdd, 1)       # => 'x2'
$tester.is_hexvs_plus('FT', 18)                 # => '+'
$tester.is_vhdvs_plus('FT', 0)                  # => '+'
$tester.is_vhdvs_hc('FTx4', :cvdd, 2)           # '_HC'

# Retrieving ATEHardware data properly
$tester.ate_hardware('HSD-M').ppmu.vclamp.min                 # => -2
$tester.ate_hardware('HSD-4G').ppmu.measv.min                 # => -1
$tester.ate_hardware('HSS-6G').ppmu.vclamp.max                # => 3.9
$tester.ate_hardware('VSM').supply.forcev.max                 # => 4
$tester.ate_hardware('VSMx2').supply.irange.max               # => 162
$tester.ate_hardware('HexVS').supply.forcev.max               # => 5.5
$tester.ate_hardware('HexVSx2').supply.filter                 # => 10_000
$tester.ate_hardware('HexVSx4').supply.bandwidth.size         # => 8
$tester.ate_hardware('HexVSx6').supply.irange.size            # => 2
$tester.ate_hardware('HexVS+').supply.forcev.max              # => 5.5
$tester.ate_hardware('HexVS+x2').supply.filter                # => 10_000
$tester.ate_hardware('HexVS+x4').supply.bandwidth.size        # => 8
$tester.ate_hardware('HexVS+x6').supply.irange.size           # => 2
$tester.ate_hardware('HDVS1').supply.sink_fold_i.min          # => 5.mA
$tester.ate_hardware('HDVS1x2').supply.meter_vrange           # => 7
$tester.ate_hardware('HDVS1x4').supply.source_fold_i.max      # => 4
$tester.ate_hardware('VHDVS').supply.irange.size              # => 6
$tester.ate_hardware('VHDVS_HC').supply.sink_fold_t.max       # => 2
$tester.ate_hardware('VHDVSx2').supply.meter_vrange           # => 18
$tester.ate_hardware('VHDVS_HCx2').supply.forcev.min          # => -2
$tester.ate_hardware('VHDVS_HCx4').supply.source_fold_t.min   # => 300.uS
$tester.ate_hardware('VHDVS_HCx8').supply.bandwidth.max       # => 255
$tester.ate_hardware('VHDVS+').supply.irange.size             # => 6
$tester.ate_hardware('VHDVS_HC+').supply.sink_fold_t.max      # => 2
$tester.ate_hardware('VHDVS+x2').supply.meter_vrange          # => 18
$tester.ate_hardware('VHDVS_HC+x2').supply.forcev.min         # => -2
$tester.ate_hardware('VHDVS_HC+x4').supply.source_fold_t.min  # => 300.uS
$tester.ate_hardware('VHDVS_HC+x8').supply.bandwidth.max      # => 255

# Pin objects are connected up to their underlying tester resource
$dut.pins(:pin1).ate_hardware.instrument                          # => 'HSD-U'
$dut.pins(:pin1).ate_hardware.ppmu.forcei.max                     # => 0.05
$dut.pins(:k1).instrument_type.instrument                         # => 'SupportBoard'
$dut.power_pin_groups(:avdd).ate_hardware.instrument              # => 'VHDVS_HC+x2'
$dut.power_pin_groups(:avdd).ate_hardware.supply.forcev.cover?(4) # => true

Tag: v0.5.6

Branch: ‘master’
by Stephen McGinty on 03-Feb-2016 09:30AM

Added initial support for Teradyne hardware configuration modelling (Scott Chen):

  • Added import_tester_config, get_tester_instrument, get_instrument_slots, import_chanmap, and get_tester_channel methods
  • import_tester_config imports a standard IG-XL generated CurrentConfig.txt so Origen application can access the instrument/slot information for test generation. get_tester_instrument and get_instrument_slots are associated methods to quickly get slot/instrument information.
  • import_chanmap imports a standard IG-XL Channelmap
  • get_tester_channel is an associated method to quickly get tester channel information.

Fixed bug causing some vectors marked as ‘dont_compress’ to be compressed anyway.

Tag: v0.5.5

Branch: ‘master’
by Daniel Hadad on 12-Nov-2015 17:56PM

Updated API support setting of diff-friendly output mode. Mainly for regression testing support.

Can be set via : ~~~ruby $tester.diff_friendly_output = true ~~~

Currently sets test number output to 0 for IG-XL program generation only.

Tag: v0.5.4

Branch: ‘master’
by Stephen McGinty on 30-Sep-2015 09:32AM

Bug fix to IG-Xl custom test instance API. If a finalize method is defined it will now be called on all instances.

Tag: v0.5.3

Branch: ‘master’
by Stephen McGinty on 29-Sep-2015 14:48PM

Added initial API to define custom test instance libraries for IG-XL based testers:

# app_interface.rb

def initialize(options = {})
  add_custom_til
end

# Example of how to use the custom library
def custom(name, options = {}) 
  ti = test_instances.mylib.test_a
  ti.my_arg0 = 'my_val'
  ti.my_arg2_alias = 'curr'
  ti.set_my_arg4('arg4_val_from_method') 
end

# Add a custom test instance library
def add_custom_til
  add_til :mylib,
          test_a: {
            # Basic arg
            my_arg0: :arg0,
            # Basic arg with default value
            my_arg1: [:arg1, 'a_default_value'],
            # Basic arg with default value and predefined set of possible values, Origen will raise  an error
            # if it is ever set to a value not in the list
            my_arg2: [:arg2, 'volt', %w(volt curr)],
            my_arg3: :arg3,
            my_arg4: :arg4,
            # Attribute aliases can be defined like this:
            aliases: {
              my_arg_alias:  :my_arg,
              my_arg1_alias: :my_arg1,
              my_arg2_alias: :my_arg2
            },
            # Define any methods you want the test instance to have
            methods: {
              # An optional finalize function can be supplied to do any final test instance configuration, this
              # function will be called immediately before the test instance is finally rendered. The test instance
              # object itself will be passed in as an argument.
              finalize:    lambda  do |ti|
                ti.my_arg3 = 'arg3_set_from_finalize'
              end,
              # Example of a custom method.
              # In all cases the test method object will be passed in as the first argument.
              set_my_arg4: lambda  do |ti, val|
                ti.my_arg4 = val
              end
            }
          },

          test_b: {
            # ...
          }
end

Tag: v0.5.2

Branch: ‘master’
by Stephen McGinty on 09-Sep-2015 05:07AM

Patch to make J750 multi-block match loops exit if any of the blocks passes. If multiple conditions should be ANDed together then the user should defined them within the same block.

Tag: v0.5.1

Branch: ‘master’
by Stephen McGinty on 02-Sep-2015 11:43AM

Various V93K updates, this version produces patterns and test program that have been verified to work on the tester

Added in the Ultraflex DSSC DigSrc and DigCap capabilities (Jiang Liu).

All possible settings were added according to Ultraflex spec. To use these new features, users must define the pins to be used with DigSrc and DigCap in the $dut/$soc file, similar to how the DCVS instrument pins are defined today.

Then the ultraflex target file should call $tester.assign_digsrc_pins, $tester.assign_digcap_pins, $tester.apply_digsrc_settings and $tester.apply_digcap_settings methods. The patterns will then contain the appropriate instrument statements for digsrc and digcap including all the settings. For overlay, the user would create a subroutine pattern which contains the necessary microcodes for digsrc overlay, the user can use $tester.digsrc_start, $tester.digsrc_stop and $tester.digsrc_send methods as the basic building blocks for building the digsrc overlay subroutine.

Please refer to the digsrc_overlay method in origen_testers/test/dut.rb for an example of constructing an digsrc overlay subroutine. Digcap only supports capture with stv right now, this is currently the main way of using it. Added two new test cases in the subroutines.rb for self-testing these newly added features.

Tag: v0.5.0

Branch: ‘master’
by Stephen McGinty on 01-Sep-2015 09:23AM

This plugin now contains the only official tester models, those from Origen core are being removed:

  • Moved Doc and CommandBasedTester modules into this plugin (from Origen core)
  • Removed all references to Origen::Testers
  • Fixed issue with pattern generation crashing if a device is defined with no pins
  • Aligned J750 match loop output to align with Origen core J750 output - basically added a clr_fail if the loop exists successfully

Tag: v0.4.1

Branch: ‘master’
by Stephen McGinty on 31-Aug-2015 08:59AM

Fix for V93K program generator regression on Ruby 2.2.2

Tag: v0.4.0

Branch: ‘master’
by Stephen McGinty on 31-Aug-2015 05:06AM

Initial Origen-based release

Tag: v0.3.0.pre43

Branch: ‘Trunk’
by Stephen McGinty on 17-Jul-2015 09:00AM

V93K updates after first round of on-tester debug:

  • Repeats <= 16 are expanded to to match what the tester does by default, thereby keeping in-pattern vector numbers in sync with those from the tester’s pattern display. A new attribute min_repeat_loop has been added to all testers to control this.
  • Re-engineering of the generated match loop code. This version proven to work on the tester. The two pin match version has not been tried yet.
  • Pattern file extensions added to pattern master files.
  • A top-level pattern master file is now output called complete.pmfl which contains the patterns required for all flows.
  • A pattern compiler control file (.aiv) is now also generated for all patterns required by a program generation run.

Tag: v0.3.0.pre42

Branch: ‘Trunk’
by Stephen McGinty on 10-Jul-2015 13:34PM

Added ability for vector levelling to maintain the same number of clock pulses when the clk transition is controlled from timing: https://rgen.freescale.net/testers/latest/api/Testers/Timing.html#timing_toggled_pins-instance_method

Added vertical pin identification comments to Teradyne patterns.

Added the ability to include vector and cycle counts in the pattern comments. Either supply “-v” to the generate command or set $tester.vector_comments in the environment/target to enable it. It is off by default since while the RGen differ will ignore them, tkdiff/winmerge will not and it will make differences harder to view.

Tag: v0.3.0.pre41

Branch: ‘Trunk’
by Ronald Lajaunie on 25-Jun-2015 12:16PM

Added Midband state to vectoring (for comparing only).

  $dut.pins(:tdo).assert_midband
  RGen.tester.cycle
  $dut.pins(:tdo).dont_care
  RGen.tester.cycle
  $dut.pins(:tdo).assert_midband!
  $dut.pins(:tdo).dont_care
  RGen.tester.cycle

  $dut.port(:test_port).assert_midband

Tag: v0.3.0.pre40

Branch: ‘Trunk’
by Stephen McGinty on 27-May-2015 09:44AM

Added a new shared command, testers:build, which provides ASCIIUtils-like test program build/integration functionality. So far only the V93K is supported but other platforms may be added in future.

The V93K implementation will currently merge flow and pattern master files which are the two files that are generated by this plugin. Additional files could be added in future.

The user must supply a manifest file which describes the flows to be built and the sub-programs from which they are comprised. The attributes of this file will be platform-dependent, here is an example for V93K:

flows:
  probe1:
    - continuity
    - scan
    - nvm
  probe2:
    - continuity
    - scan
    - functional

sub_programs:  
  - name:           continuity
    # Paths can be relative to your RGen application root
    flow:           output/v93k/testflow/continuity.flow

  - name:           scan
    # Or relative to this file
    flow:           ../../output/v93k/testflow/scan.flow
    pattern_master: ../../output/v93k/vectors/scan.pmfl

  - name:           nvm
    # Or absolute
    flow:           /proj/deviceX/test_program/v93k/testflow/nvm.flow
    pattern_master: /proj/deviceX/test_program/v93k/testflow/nvm.pmfl

  - name:           functional
    flow:           /proj/deviceX/test_program/v93k/testflow/functional.flow
    pattern_master: /proj/deviceX/test_program/v93k/testflow/functional.pmfl

A template manifest file can be built by running:

rgen testers:build my_manifest --new

Tag: v0.3.0.pre39

Branch: ‘Trunk’
by Stephen McGinty on 22-May-2015 10:12AM
  • More test cases and improvements to V93K generator, mainly in the area of nested flow control directives.
  • Added support for limits (V93K):
test_method = test_methods.j750_tml.general_dc
test_method.lo_limit = 100.uA
test_method.hi_limit = 150.uA
  • Added ability to define methods when defining a custom V93K test method from an application, via an optional methods hash. The finalize method added recently is still supported but it should now be placed within the methods hash per the example below:
module MyApp
  class Interface
    include Testers::ProgramGenerators

    def initialize(options={})
      add_j750_tml if tester.v93k?
    end

    # Define the test methods for the J750 test method library for the V93K
    def add_j750_tml
      add_tml :j750_tml,
        class_name:      'J750Conversion',
        general_dc: {
          class_name:   'DigitalTest.GeneralDC',
          # Parameters can be defined with an underscored symbol as the name, this can be used
          # if the C++ implementation follows the standard V93K convention of calling the attribute
          # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
          # first example.
          # The attribute definition has two required parameters, the type and the default value.
          # The type can be :string, :current, :voltage, :time, :frequency, or :integer 
          # An optional 3rd parameter can be supplied to give an array of allowed values. If supplied,
          # RGen will raise an error upon an attempt to set it to an unlisted value.
          tester_state: [:string, 'CONNECTED', %w(CONNECTED UNCHANGED)],
          test_name: [:string, 'Functional'],
          # Parameters for PPMU
          'UsePPMU' => [:string, 'YES', %w(YES NO)],
          'UsePPMU.pinlist' => [:string, ''],
          'UsePPMU.forceMode' => [:string, 'VOLT', %w(VOLT CURR)],
          'UsePPMU.forceValue1' => ['UsePPMU.forceMode', 3800.mV],
          'UsePPMU.forceValue2' => ['UsePPMU.forceMode', 0],
          'UsePPMU.measureMode' => [:string, 'PAR', %w(PAR SER)],
          'UsePPMU.samples' => [:integer, 1],
          'UsePPMU.precharge' => [:string, 'OFF', %w(OFF ON)],
          'UsePPMU.prechargeVoltage' => [:voltage, 0],
          'UsePPMU.relaySwitchMode' => [:string, 'PARALLEL', ['BBM', 'MBB', 'PARALLEL(default)', 'PARALLEL']],
          'UsePPMU.settlingTime' => [:time, 0],
          'UsePPMU.termination' => [:string, 'OFF', %w(ON OFF)],
          'UsePPMU.testName1' => [:string, ''],
          'UsePPMU.testName2' => [:string, ''],
          # In cases where the C++ library has deviated from standard attribute naming conventions
          # (camel-cased with lower cased first character), the absolute attribute name can be given
          # as a string.
          # The Ruby/RGen accessor for these will be the underscored version, with '.' characters
          # converted to underscores, e.g. tm.use_interpose, tm.use_interpose_start_of_body_f, etc.
          'UseInterpose' => [:string, 'NO', %w(NO YES)],
          'UseInterpose.StartOfBodyF' => [:string, ''],
          'UseInterpose.StartOfBodyFInput' => [:string, ''],
          'UseInterpose.EndOfBodyF' => [:string, ''],
          'UseInterpose.EndOfBodyFInput' => [:string, ''],
          # Attribute aliases can be defined like this:
          aliases: {
            start_of_body_f: 'UseInterpose.StartOfBodyF',
            start_of_body_f_args: 'UseInterpose.StartOfBodyFInput',
            end_of_body_f: 'UseInterpose.EndOfBodyF',
            end_of_body_f_args: 'UseInterpose.EndOfBodyFInput',
          },
          # Define any methods you want the test method to have
          methods: {
            # An optional finalize function can be supplied to do any final test method configuration, this
            # function will be called immediately before the test method is finally rendered. The test method
            # object itself will be passed in as an argument.
            # In this example it is being used to automatically set the UseInterpose flag if any interpose
            # function arguments have been set.
            finalize: -> (tm) {
              if [:start_of_body_f, :start_of_body_f_args, :end_of_body_f, :end_of_body_f_args].any? do |arg| 
                  tm.send(arg) && !tm.send(arg).empty?
                end
                tm.use_interpose = "YES" 
              end
            },
            # Example of a custom method, here to emulate functionality available to Teradyne test instance objects.
            # In all cases the test method object will be passed in as the first argument.
            set_measure_mode: -> (tm, mode) {
              if mode == :current || mode == :fvmi
                tm.use_ppmu_force_mode = "VOLT"
              elsif mode == :voltage || mode == :fimv
                tm.use_ppmu_force_mode = "CURR"
              end
            },
          }
        },
        
        general_digital: {
          # Define another test method within this library... 

        }
    end
end

Tag: v0.3.0.pre38

Branch: ‘Trunk’
by Stephen McGinty on 19-May-2015 09:01AM
  • Fixed issue with multi-mode not padding to complete a partial vector group at the end of the pattern.
  • Various improvements and additional test cases added to the V93K flow control API.
  • Made V93K test_suites delegate method calls to their test_method, this means that a test_suite
    • test_method combo can be used as a drop in replacement for a Teradyne test_instance object within a multi-platform interface:
if tester.j750?
  i = test_instances.functional(name, options)
elsif tester.v93k?
  i = test_suites.add(name, options)
  i.test_method = test_methods.j750_tml.general_digital
end
# Now you can treat these the same for many attributes. For example on V93K the pattern is
# a test suite attribute whereas the interpose functions are provided by the (custom) test
# method, however these can now be treated as if they are a single entity:
i.pattern = name
i.start_of_body_f = "TfsC90InterposeFunc"
i.start_of_body_f_args = "PGM_CAL_PARAS,cal_paras"
  • Added an API to allow applications to define custom V93K test methods:
module MyApp
  class Interface
    include Testers::ProgramGenerators

    def initialize(options={})
      add_j750_tml if tester.v93k?
    end

    # Define the test methods for the J750 test method library for the V93K
    def add_j750_tml
      # Add a new test method library, this will be available as test_methods.j750_tml.
      # This method can be called multiple times to define multiple custom libraries.
      add_tml :j750_tml,
        # Optionally supply a class name attribute that will be prefixed to all test method
        # classes (meaning the C++ class name) defined herein
        class_name:      'J750Conversion',
        # Defines a test method called general_digital, a new instance of this can be created
        # by test_methods.j750_tml.general_digital
        general_digital: {
          # The full C++ class name will be 'J750Conversion.DigitalTest.GeneralDigital', this
          # is optional and by default will be the camel-cased version of the method name, e.g.
          # 'GeneralDigital' in this case.
          class_name:   'DigitalTest.GeneralDigital',
          # Parameters can be defined with an underscored symbol as the name, this can be used
          # if the C++ implementation follows the standard V93K convention of calling the attribute
          # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
          # first example.
          # The attribute definition has two required parameters, the type and the default value.
          # The type can be :string, :current, :voltage, :time, :frequency, or :integer 
          # An optional 3rd parameter can be supplied to give an array of allowed values. If supplied,
          # RGen will raise an error upon an attempt to set it to an unlisted value.
          tester_state: [:string, 'CONNECTED', %w(CONNECTED UNCHANGED)],
          test_name: [:string, 'Functional'],
          # In cases where the C++ library has deviated from standard attribute naming conventions
          # (camel-cased with lower cased first character), the absolute attribute name can be given
          # as a string.
          # The Ruby/RGen accessor for these will be the underscored version, with '.' characters
          # converted to underscores, e.g. tm.use_interpose, tm.use_interpose_start_of_body_f, etc.
          'UseInterpose' => [:string, 'NO', %w(NO YES)],
          'UseInterpose.StartOfBodyF' => [:string, ''],
          'UseInterpose.StartOfBodyFInput' => [:string, ''],
          'UseInterpose.EndOfBodyF' => [:string, ''],
          'UseInterpose.EndOfBodyFInput' => [:string, ''],
          # Attribute aliases can be defined like this:
          aliases: {
            start_of_body_f: 'UseInterpose.StartOfBodyF',
            start_of_body_f_args: 'UseInterpose.StartOfBodyFInput',
            end_of_body_f: 'UseInterpose.EndOfBodyF',
            end_of_body_f_args: 'UseInterpose.EndOfBodyFInput',
          },
          # An optional finalize function can be supplied to do any final test method configuration, this
          # function will be called immediately before the test method is finally rendered. The test method
          # object itself will be passed in as an argument.
          # In this example it is being used to automatically set the UseInterpose flag if any interpose
          # function arguments have been set.
          finalize: -> (tm) {
            if [:start_of_body_f, :start_of_body_f_args, :end_of_body_f, :end_of_body_f_args].any? do |arg| 
                tm.send(arg) && !tm.send(arg).empty?
              end
              tm.use_interpose = "YES" 
            end
          }
        },
        
        general_dc: {
          # Define another test method within this library... 

        }
    end
end

Tag: v0.3.0.pre37

Branch: ‘Trunk’
by Stephen McGinty on 04-May-2015 10:37AM

Added fixes (and tests) for the following two bugs:

  • Fixed non-optimal compression in single mode:
OLD:

// Wait for 2.4ms
repeat     60000     nvmbist     0 1 0 1 0 X X X 
repeat               nvmbist     0 1 0 1 0 X X X 

NEW:

// Wait for 2.4ms
repeat     60001     nvmbist     0 1 0 1 0 X X X 
  • Fixed duplicate repeat issue at end of pattern in dual mode:
OLD:

// Wait for 12.0us
                                    > lynx                         1 
repeat 600                          > lynx                         1 
// COMMENT: End Test
repeat 600                          > lynx                         1 
                                    > lynx                         1 
}                                                                                               

NEW:

// Wait for 12.0us
                                    > lynx                         1 
repeat 600                          > lynx                         1 
// COMMENT: End Test
                                    > lynx                         1 
                                    > lynx                         1 
}                                                                                               

Tag: v0.3.0.pre36

Branch: ‘Trunk’
by Daniel Hadad on 27-Apr-2015 16:03PM

Corrected minor bug that only occurred when tester wait called for time greater than maximum repeat count possible on tester. Extraneous vector was being generated after each max repeat count vector.

Tag: v0.3.0.pre35

Branch: ‘Trunk’
by Stephen McGinty on 23-Apr-2015 03:07AM

Added fix (and test) for setting resources_filename during interface initialize.

This update also ensures that the given platform generator module is loaded before initialize is called where an interface includes Testers::ProgramGenerators.

Tag: v0.3.0.pre34

Branch: ‘Trunk’
by Stephen McGinty on 21-Apr-2015 08:31AM

Changed internal implementation of TestInstance#set_wait_flags method to remove the need for a tester instance method

Tag: v0.3.0.pre33

Branch: ‘Trunk’
by Stephen McGinty on 17-Apr-2015 09:12AM

Initial release of the V93K test program generator and general feature improvements to support the creation of test programs for multiple platforms.

V93K

The V93K generator now has a similar level of functionality to the supported Teradyne platforms, here is an example of how to use it:

# Generate a functional test
def functional(name, options = {})
  test_suite = test_suites.run(name, options)
  test_method = test_methods.ac_tml.ac_test.functional_test
  test_suite.test_method = test_method
  test_suite.pattern = name
  flow.test(test_suite, options)
end

The output is a complete flow file containing all test method and test suite definitions (equivalent to Teradyne test instances + patsets) and a pattern master file listing all patterns required by the given flow.

Notable things still todo:

  • The output has not been tried live yet. Although it is definitely generating valid V93K syntax there could be typo-like bugs.
  • The flow control API is implemented with the exception of the if_any and if_all passed/failed options. V93K does not provide native support for these and discussion is ongoing about whether to deprecate these from the flow control API or possibly to implement on V93K via a C++ shim.
  • All SmarTest built-in DC test methods have been implemented, however only a subset of the AC tests have been implemented so far. This is just a tedious and manual job and will be done in due course.
  • How to handle custom test methods has still to be defined and will be worked out in the course of creating the first application to use this generator (C90TFS NVM).

NEW MULTI-PLATFORM FEATURES

The following features have been added to the Testers plugin to better support multi-platform test program generation (i.e. to make it easier to implement an app that supports multiple platforms), and also to make the program generator work better in a BOM-style application.

Previously, test program interfaces were automagically selected based on the current tester type, however that won’t work in a BOM app setup where potentially many sub-modules each implement their own interface (or they could share one) and it is impossible to know which one to pick. To solve this, top-level flows (i.e. not required for sub-flows which will inherit the interface from their parent) should now define the class of the interface that they want to use:

Flow.create interface: 'C90TFSNVMTester::Interface' do

end

For now this is optional and the old-style lookup is still supported, but that will eventually be deprecated and supplying an interface option will be a hard required.

Note that the above interface example does not specify a test platform, this is because it is now possible to create a universal interface. Instead of including platform-specific generators, an app’s interface class can now include just a universal generator module:

module C90TFSNVMTester
  class Interface
    include Testers::ProgramGenerators
  end
end

The interface instance will be automatically endowed with the methods to support the test platform being used at runtime. The bottom line is that an interface to support the J750 would otherwise be identical to how it used to be:

module C90TFSNVMTester
  class Interface
    include Testers::ProgramGenerators

    def functional(name, options = {})
      ins = test_instances.functional(name, options)
      pname = "#{name}_pset"
      pset = patsets.add(pname, [{ pattern: "#{name}.PAT" }])
      ins.pattern = pname
      line = flow.test(ins, options)
    end
  end
end

Note that this means that the above interface would now also support UltraFLEX as well if it was run with the appropriate target.

It is now much easier to add support for additional test platforms rather than having separate interfaces and trying to juggle shared code between them. To add V93K support to the above interface you would do:

module C90TFSNVMTester
  class Interface
    include Testers::ProgramGenerators

    def functional(name, options = {})
      if tester.j750? || tester.ultraflex?
        ins = test_instances.functional(name, options)
        pname = "#{name}_pset"
        pset = patsets.add(pname, [{ pattern: "#{name}.PAT" }])
        ins.pattern = pname
        line = flow.test(ins, options)
      elsif tester.v93k?
        test_suite = test_suites.run(name, options)
        test_method = test_methods.ac_tml.ac_test.functional_test
        test_suite.test_method = test_method
        test_suite.pattern = name
        flow.test(test_suite, options)
      end
    end
  end
end

This now opens the door to the creation of multi-platform test setup libraries (which was always the intention of the architecture design of the RGen program generator) and the Testers plugin will provide a basic library to make it easier to get started when dealing with basic tests (e.g. functional, current_measure, voltage_measure, etc.). It is of course envisaged that more complex domain-specific libraries will start to emerge within the community.

Initially the Tester plugin’s basic library is a proof of concept and provides a functional test setup which will work on all platforms (though it has not yet been tested on any).

To use it create a very simple interface in your app:

module C90TFSNVMTester
  class Interface
    include Testers::BasicTestSetups
  end
end

In your flow you can now generate functional tests for any platform:

Flow.create interface: 'C90TFSNVMTester::Interface' do
  functional :erase,   sbin: 100
  functional :rd_all1, sbin: 110
end

It is possible to apply defaults (e.g. set bin 3 for all), or to tweak the output (e.g. add an interpose function call on Teradyne platforms) from the interface. See the API for details on how to do that: BasicTestSetups

Tag: v0.3.0.pre32

Branch: ‘Trunk’
by Daniel Hadad on 08-Apr-2015 18:37PM

Corrected bug in J750 match loop with multiple entries– extra set_code being called.

Tag: v0.3.0.pre31

Branch: ‘Trunk’
by Stephen McGinty on 02-Apr-2015 05:08AM

Fix for issue when requiring into a 3rd party app (introduced in pre29)

Tag: v0.3.0.pre30

Branch: ‘Trunk’
by Stephen McGinty on 31-Mar-2015 04:01AM

Updated the V93K generator class structure to match the conventions recently established for the IG-XL-based testers.

Added V93K interface and added the V93K program generator to the regression list (though it doesn’t currently generate any output).

Now ready to start adding functionality…

Tag: v0.3.0.pre29

Branch: ‘Trunk’
by Stephen McGinty on 30-Mar-2015 05:58AM

Fairly major internal refactor to support running multiple program generation runs back to back, this is necessary amongst other things to support testing the program generators. Regression tests have now been enabled for the J750, UltraFLEX and J750_HPT program generators.

This update restores the internal generator architecture to have a separate class structure for each supported platform, rather than customizing a single class at runtime. Unfortunately some fairly minor breaking changes will be apparent at application-level as a result of this change:

  • The interface definition is now the same as RGen core and no self.platform method is required, to create an interface just include the appropriate generator module:
class MyJ750Interface
  include Testers::J750::Generator
end
  • The J750_HPT now requires a dedicated interface to be setup for it, see the example in lib/testers/test/ for how to do this while sharing the bulk of the code with a J750 interface.

The patgroup generators are currently untested and could therefore be broken by this update, though it is unlikely.

Tag: v0.3.0.pre28

Branch: ‘Trunk’
by Stephen McGinty on 19-Mar-2015 10:12AM

Added vector levelling.

When enabled, all vectors will be converted to use the timeset with the smallest period that is encountered in the pattern. An error will be raised if a vector is encountered who’s period is not a multiple of the smallest period.

This feature is enabled for the V93K tester by default and disabled for Teradyne testers since there is no time penalty from modulating the period by switching timeset/timeplate on that platform.

Tag: v0.3.0.pre27

Branch: ‘Trunk’
by Stephen McGinty on 18-Mar-2015 12:36PM

Removed the original vector compression logic and made everything, including single mode patterns, now use the vector pipeline. This is to allow it to be used to create a period-levelling system which will be required for the V93K.

Added $tester.align and $tester.align_to_last methods to align the next vector to the start or end of a multi-vector frame. See the pattern_footer method in the IGXL-based tester class for an example where it is used to ensure that the end_module microcode falls on the last vector of a frame. Generally the tester classes will be responsible now for using these methods as required to ensure that their microcode will align properly in multi vector modes.

Added a multi-mode vector test to the regression list. The J750 output matches that from RGen core, not sure if the output on other platforms is valid yet - especially may not be right for UFlex case where vector padding kicks in on short patterns. This multi-mode pattern should be expanded in future as tester API methods become multi-mode aware.

Added more test coverage for V93K.

Tag: v0.3.0.pre26

Branch: ‘Trunk’
by Stephen McGinty on 13-Mar-2015 06:43AM

Added V93K generators from RGen core, without modification other than that required to make them run within the Testers plugin.

Added legacy test of V93K pattern generation compatibility to allow it to be safely deprecated from RGen core.

Enabled standard auto-linting.

Did some minor refactoring of existing code.

Tag: v0.3.0.pre25

Branch: ‘Trunk’
by Daniel Hadad on 02-Feb-2015 16:15PM

Wrapped standalone-dependent configs so that they aren’t run by app calling Testers gem.

Tag: v0.3.0.pre24

Branch: ‘Trunk’
by Daniel Hadad on 06-Jan-2015 14:17PM

Converted to gem.

Tag: v0.2.0.dev23

Branch: ‘Trunk’
by Daniel Hadad on 12-Dec-2014 17:45PM

Added MTO instrument statement back for all UltraFLEX patterns but controlled via target. So by default will not be included for all patterns but user can add it if desired.

Tag: v0.2.0.dev22

Branch: ‘Trunk’
by Aaron J Burgmeier on 06-Dec-2014 16:17PM

updated pattern generation for multi-mode vector support - correct repeat counts are now being properly applied on the correct vectors. Vector padding is also being applied to fill out a complete vector group. Also vector repeats are also being split in order to preserve vector comments in their original position. Pattern header content has been adjusted to reflect the correct UltraFlex mode (single, dual, quad).

NOTE: An instrument statement for ‘mto’ was being erroneously included in all pattern headers. This has been changed such that it will only be included if the :memory_test option is set to true for the pattern header (this is the same solution used in the igxl_based_tester class). Be aware that this caused ‘rgen examples’ to fail four patterns that expected the ‘mto’ instrument to be declared. I have updated these patterns with the new pattern generation behavior (e.g. without the mto instrument).

Tag: v0.2.0.dev21

Branch: ‘Trunk’
by Daniel Hadad on 21-Nov-2014 22:58PM

Changes in this release

  • Modifed to rely less on Tester module in RGen core and more on additional files now placed in Testers plug-in. Confirmed to work with RGen core files temporarily removed (but not yet so as to permit deprecate warnings to users). This is to allow future modifications to be able to be done directly in Testers plug-in.
  • Reverted back to $dut instance naming from $soc.
  • Rgen examples for this plug-in using UltraFLEX target only instead of J750 for program command–due to bug noted below were examples can’t run multiple testers. UltraFLEX currently in higher use for this plug-in.
  • Minor fixes that were preventing UltraFLEX regression testing.

Known issues:

  • Running multiple targets back to back for program generation across different testers giving issue. Only impacts ‘rgen examples’ command but needs to be fixed soon.
  • Does not support proper placement of stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
  • Added concept of Pattern subroutine sheets to code– not yet fully supported.

Checkouts performed:

  • rgen examples (now will always have to pass prior to release)

Features not yet supported:

  • Program Parsing (there but needs test case)
  • V93K support (almost there)
  • UF MTO support (custom template used today, need to add to library)

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.2.0.dev20

Branch: ‘Trunk’
by Brian Caquelin on 17-Nov-2014 11:07AM

Fixed bug where compiler woulf crash if users had not previously created a .atp file.

All of these bugs I am finding are due to writing documentation on how the compiler SHOULD work and it is clear that good, prompt documentation will improve our code base or at least my contributions to it.

Tag: v0.2.0.dev19

Branch: ‘Trunk’
by Brian Caquelin on 17-Nov-2014 10:11AM

Updated compiler to look for cmd line .atp patterns at RGen.root and below

Tag: v0.2.0.dev18

Branch: ‘Trunk’
by Brian Caquelin on 14-Nov-2014 12:22PM

updated ultraflex compiler to version 1.5.3.3

Tag: v0.2.0.dev17

Branch: ‘Trunk’
by Brian Caquelin on 10-Nov-2014 09:54AM

updated pattern compiler to handle callbacks natively instead of inside the user application

Tag: v0.2.0.dev16

Branch: ‘Trunk’
by Priyavadan Kumar on 10-Nov-2014 09:49AM

Updated the testers plugin to enable bitmapping support on the UltraFLEX using the MTO instrument.

Tag: v0.2.0.dev15

Branch: ‘Trunk’
by Brian Caquelin on 07-Nov-2014 11:45AM

updated pattern compiler to work with ‘rgen g’

Tag: v0.2.0.dev14

Branch: ‘Trunk’
by Brian Caquelin on 07-Nov-2014 08:28AM

Added in pattern compiler support for programmatic access. This works as follows:

module CompilerSpec
  class CompilerDUT
    include Testers::PatternCompilers
    include RGen::TopLevel

    attr_accessor :pinmap
    attr_reader   :ltg_compiler_options
    attr_reader   :functional_compiler_options
    attr_reader   :bist_compiler_options

    def initialize
      @ltg_compiler_options = {
        path: "#{RGen.root}/spec/patterns/atp/ltg",
        clean: false,
        location: :local,
        recursive: false,
        output_directory: "#{RGen.root}/spec/patterns/bin",
        opcode_mode: 'single',
        comments: true
      }

      @functional_compiler_options = {
        path: "#{RGen.root}/spec/patterns/atp/functional",
        clean: true,
        location: :local,
        recursive: false,
        output_directory: "#{RGen.root}/spec/patterns/bin",
        opcode_mode: 'single',
        comments: false
      }

      @bist_compiler_options = {
        clean: true,
        location: :local,
        recursive: false,
        output_directory: "#{RGen.root}/spec/patterns/bin",
        pinmap_workbook: "#{RGen.root}/spec/patterns/atp/bist/bist_pins.txt",
        opcode_mode: 'single',
        comments: false
      }
    end
  end

  describe "Ultraflex Pattern Compiler" do

    before :all do
      RGen.target.temporary = 'ultraflex_compiler'
      RGen.app.load_target!
      RGen.load_application
      $dut = CompilerDUT.new
      $dut.pinmap = "#{RGen.root}/spec/patterns/compiler_pins.txt"
      # Clean up any .PAT and .log files in our spec testing area
      Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").each do |f|
        File.delete(f)
      end
      Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").each do
|f|
        File.delete(f)
      end
      Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").each do |f|
        File.delete(f)
      end
      Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").each do |f|
        File.delete(f)
      end
    end

    it "creates pattern compiler instances correctly" do
      $dut.pattern_compilers.should == {}
      $dut.add_compiler(:ltg, :ultraflex, $dut.ltg_compiler_options)
      # pattern_compiler method will show compiler instances
      # for whatever the current tester platform is enabled
      $dut.pattern_compilers.keys.should == [:ltg]
      $dut.add_compiler(:functional, :ultraflex, $dut.functional_compiler_options)
      $dut.pattern_compilers.count.should == 2
    end

    it "finds the correct number of patterns" do
      $dut.pattern_compilers[:ltg].find_jobs
      ltg_atp_count = $dut.pattern_compilers[:ltg].count
      ltg_atp_count.should == 1
    end

    it "can search the compiler job queue" do
      $dut.pattern_compilers[:ltg].jobs(/fail/).should == false
      $dut.pattern_compilers[:ltg].jobs(/idreg/).should == true
      $dut.pattern_compilers[:ltg].jobs('ls2080').should == true
      $dut.pattern_compilers[:ltg].jobs(0).should == true
      $dut.pattern_compilers[:ltg].jobs($dut.pattern_compilers[:ltg].count+1).should ==
false
    end

    it "can compile the expected number of patterns" do
      ltg_atp_count = $dut.pattern_compilers[:ltg].count
      ltg_atp_count.should == 1
      ltg_pat_matches =
Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").count
      ltg_pat_matches.should == 0
      $dut.pattern_compilers[:ltg].run
      ltg_pat_matches =
Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").count
      ltg_atp_count.should == ltg_pat_matches
    end

    it "can save log files" do
      ltg_pat_matches =
Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").count
      if $dut.ltg_compiler_options[:clean] == false
        Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").count.should ==
ltg_pat_matches
      else
        Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").count.should == 0
      end
    end

    it "can find and compile patterns recursively/non-recursively in directories and
lists" do
      # Clean up patterns and log files from previous spec testing
      Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").each do |f|
        File.delete(f)
      end
      Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").each do |f|
        File.delete(f)
      end
      $dut.pattern_compilers[:functional].find_jobs
      functional_atp_count = $dut.pattern_compilers[:functional].count
      functional_atp_count.should == 1
      functional_pat_matches =
Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count
      functional_pat_matches.should == 0
      $dut.pattern_compilers[:functional].run
      functional_pat_matches =
Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count
      functional_atp_count.should == functional_pat_matches
      # Turn on the recursive flag which will find patterns and lists in sub-directories
      $dut.functional_compiler_options[:recursive] = true
      $dut.add_compiler(:functional_recursive, :ultraflex,
$dut.functional_compiler_options)
      $dut.pattern_compilers[:functional_recursive].find_jobs
      functional_atp_count = $dut.pattern_compilers[:functional_recursive].count
      functional_atp_count.should == 7
      functional_pat_matches =
Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count
      # Should have one pattern from previous run
      functional_pat_matches.should == 1
      $dut.pattern_compilers[:functional_recursive].run
      functional_pat_matches =
Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count
      functional_atp_count.should == functional_pat_matches
    end

    it "can delete log files" do
      functional_pat_matches =
Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count
      if $dut.functional_compiler_options[:clean] == false
        Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").count.should ==
functional_pat_matches
      else
        Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").count.should == 0
      end
    end

    it "allows users to pass files individually inside an enumeration" do
      # Clean up patterns and log files from previous spec testing
      Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").each do
|f|
        File.delete(f)
      end
      Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").each do |f|
        File.delete(f)
      end
      # This compiler instance does not specify path but does specify a pinmap
      # The pinmap passed as an option should override $dut.pinmap
      $dut.add_compiler(:bist, :ultraflex, $dut.bist_compiler_options)
      # The pinmap passed to the compiler as an option overrode the one at $dut.pinmap
      $dut.pinmap.should_not == $dut.pattern_compilers[:bist].pinmap.to_s
      bist_pattern_count = Dir["#{RGen.root}/spec/patterns/atp/bist/*.atp*"].count
      Dir["#{RGen.root}/spec/patterns/atp/bist/*.atp*"].each do |f|
        atp = Pathname.new(f)
        next unless atp.extname == '.gz' || atp.extname == '.atp'
        # Ignore patterns that do not have 'prod' in the name
        next unless atp.basename.to_s.match(/prod/)
        $dut.pattern_compilers[:bist].find_jobs(atp)
      end
      # Filtered one pattern
      $dut.pattern_compilers[:bist].count.should == 3
      # Save the compiler queue to a pattern list file for diff or run later
      $dut.pattern_compilers[:bist].to_list(name: 'bist_compile', force: true,
output_directory: $dut.bist_compiler_options[:output_directory])
      $dut.pattern_compilers[:bist].run
      bist_pat_matches =
Dir.glob("#{$dut.bist_compiler_options[:output_directory]}/**/*.PAT").count
      bist_pat_matches.should == bist_pattern_count - 1
      # Clean up patterns and log files from previous spec testing
      Dir.glob("#{$dut.bist_compiler_options[:output_directory]}/**/*.PAT").each do |f|
        File.delete(f)
      end
      $dut.pattern_compilers[:bist].count.should == 0
    end

    it "can compile a pattern list" do
      # Compile the patterns using the pattern list created ea
      $dut.pattern_compilers[:bist].run(list, $dut.bist_compiler_options)
      bist_pat_matches =
Dir.glob("#{$dut.bist_compiler_options[:output_directory]}/**/*.PAT").count
      # compiled patterns count should match what we had when we wrote out the pattern
list
      bist_pat_matches.should == 3
    end
  end
end

Also added hooks to allow ‘rgen g --compile ' to kick off compiler but it is not tested yet.

Tag: v0.2.0.dev13

Branch: ‘Trunk’
by Jiang Liu on 22-Oct-2014 17:54PM
  • changed the import of instruments for J750 and Uflex to near the end of pattern header to prevent pattern compilation error on uflex (where order matters).

Tag: v0.2.0.dev12

Branch: ‘Trunk’
by Jiang Liu on 22-Oct-2014 10:47AM
  • Added uflex capability of fetching and returning dut dc_pins, which allows dc instrument to be imported into pattern based on requirements.
  • Uflex example patterns would now import the dc instrument in the pattern as a check of this feature.

Tag: v0.2.0.dev11

Branch: ‘Trunk’
by Brian Caquelin on 19-Oct-2014 08:00AM

Updated linux pattern compiler to work on cmd line AND offline so compile jobs can be done and prepared on Windows or Linux. Cmd line args changed slightly:

opt_parser = OptionParser.new do |opts|
  opts.banner = 'USAGE: rgen latpc [options] ; --pinmap is required.'
  opts.on('-f', '--path DIR|PATTERN|LIST', 'Pattern directory, individual pattern, or
pattern list to be compiled.  Required.') { |path| options[:path] = path }
  opts.on('-p', '--pinmap PINMAP', 'Path and filename for the pinmap to be used.
Required.') { |pinfile| options[:pinmap_workbook] = pinfile }
  opts.on('-o', '--output DIRECTORY', 'Path to the directory to place compiled .PAT
files') { |dir| options[:output_directory] = dir }
  opts.on('-c', '--clean', 'Deleted .log files after compilation') { |a| boptions[:clean]
= true }
  opts.on('-t', '--target TARGET', 'Temporarily changes target to TARGET for this
command') { |tar| options[:target] = tar }
  opts.on('-l', '--location LOCATION', "'local' or 'lsf', defaults to 'local'") { |locn|
options[:location] = locn }
  opts.on('-r', '--recursive', "Do a recursive directory search for patterns if the '-f'
arg is a directory") { |r| options[:recursive] = true }
  opts.on_tail('-h', '--help', 'Show this message') { puts opts; exit }
end

When using the compiler offline (inside RGen) the following steps are required:

bist_options = {
  path: "#{RGen.root}/output/patterns/atp/fslbist",
  clean: true,          # controls whether compiler log files are deleted after
compilation
  target: nil,           # allows user to temporarily set target and run compilation
  location: 'local',     # controls whether the commands go to the LSF or run locally
  recursive: false,      # controls whether to look for patterns in a directory
recursively
  output_directory: "#{RGen.root}/output/patterns/bin",
  pinmap_workbook: "#{RGen.root}/output/patterns/atp/fslbist/Pins.txt",
  opcode_mode: 'dual',
  comments: true
}
compiler = Testers::LinuxPatternCompiler.new(:fslbist, bist_options)
compiler.find_jobs # Find all patterns at options[:path] and create compiler jobs
compiler.run # Run the compiler using the jobs queue built by 'find_jobs' method

Users can view the compiler job queue by doing the following:

compiler.inspec_jobs

| Job:       1 |          Pattern: ls2080_lnx_07p2p1_idreg.atp                            
|
|              |     Pattern type: cmd_line                                               
|
|              |           Pinmap:
/proj/b4860/b07507/ls2085/rev1.0.0dev3/output/programs/ls2080_pins.txt                    
|
|              |   .atp directory:
/proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/atp/ltg                            
|
|              |   .pat directory:
/proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/bin/ltg                            
|
|              |              LSF: true                                                   
|
|              | Delete log files: false                                                  
|
|              |    Compiler args: -opcode_mode:single                                    
|
------------------------------------------------------------------------------------------
---------------------------------------------

Users can view the current state of the compiler by doing the following:

compiler.inspect

|            Option            |                                       Argument           
| Required |
------------------------------------------------------------------------------------------
----------------------------------------
| path                         | output/patterns/atp/ltg                                  
|   true   |
| reference_dir                |
/proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/atp                           |  
false  |
| recursive                    | false                                                    
|   false  |
| compiler                     |
/proj/b4860/b07507/ls2085/.rev1.0.0dev3_imports_DO_NOT_HAND_MODIFY/testers/bin/atpc_Linux6
4_til/bin/atpcompiler|   true   |
| pattern_type                 | cmd_line                                                 
|   true   |
| pinmap_workbook              |
/proj/b4860/b07507/ls2085/rev1.0.0dev3/output/programs/ls2080_pins.txt               |  
true   |
| location                     | lsf                                                      
|   false  |
| clean                        | false                                                    
|   false  |
| output_directory             |
/proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/bin                           |  
false  |
| opcode_mode                  | single                                                   
|   false  |

Users can save a compiler job queue by creating a pattern list which can then be run at a later time.

compiler.to_list(name: 'test', output_directory: '~', force: true, expand: true)

options = {
        name: nil,
        directory: Dir.pwd,
        clean: false,
        location: 'local'
      }.update_common(list_options)

~~ruby options = { name: @pattern_type, output_directory: Dir.pwd, expand: true, force: false }.update_common(options) ~~~

The compiler can handle individual .atp, .atp.gz, .list files or a directory which can be parsed recursively or flat.

By allowing the users to instantiate a particular type of compiler for each pattern type that has unique compiler options required, standardization is enforced.

By allowing the users to send files or directories to the compiler inside of any Ruby loop/enumeration the user has much more flexibility in what get sent to the job queue vs. running strictly on the command line.

Tag: v0.2.0.dev10

Branch: ‘Trunk’
by Daniel Hadad on 14-Oct-2014 16:39PM

Changes in this release

  • Updated program command used in examples to use prod.list file– to force order of execution causing fewer problems in failing ‘rgen examples’.
  • Added improved instruments management method to handle MTO (J750) and DCVS (UF) instrument argument handling at start of pattern. Added appropriate test case patterns.
  • Added forcing of checking that ‘rgen examples’ passes prior to any new release.
  • Removed force fail when generating MTO patterns for UF. Currently doesn’t have MTO capability yet but coming soon…

Known issues:

  • Running multiple targets back to back for program generation across different testers giving issue. Only impacts ‘rgen examples’ command but needs to be fixed soon.
  • Does not support proper placement of stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
  • Added concept of Pattern subroutine sheets to code– not yet fully supported.

Checkouts performed:

  • rgen examples (now will always have to pass)

Features not yet supported:

  • Program Parsing
  • V93K support
  • UF MTO support

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.2.0.dev9

Branch: ‘Trunk’
by Brian Caquelin on 10-Oct-2014 16:34PM

updated linux pattern compiler to use single file, pattern list, or directory (flat or recusive).

Command line args have changed slightly:

  opts.on("-f", "--file DIR|PATTERN|LIST", "Pattern directory, individual pattern, or
pattern list to be compiled.  Required.") { |path| options[:path] = path }
  opts.on("-p", "--pinmap PINMAP", "Path and filename for the pinmap to be used.
Required.") { |pinfile| options[:pinmap] = pinfile }
  opts.on("-o", "--output DIRECTORY", "Path to the directory to place compiled .PAT
files") { |dir| options[:output] = dir }
  opts.on("-c", "--clean", "Deleted .log files after compilation") {|a|
options[:clean]=true}
  opts.on("-t", "--target TARGET", "Temporarily changes target to TARGET for this
command") { |tar| options[:target] = tar }
  opts.on("-l", "--lsf", "Submit job to the LSF") { |a| options[:lsf] = true}
  opts.on("-r", "--rec", "Do a recursive directory search for patterns if the '-f' arg is
a directory") { |r| options[:rec] = true }
  opts.on_tail("-h", "--help", "Show this message") { puts opts; exit }

Tag: v0.2.0.dev8

Branch: ‘Trunk’
by Thao Huynh on 08-Oct-2014 14:03PM
  • Added MTO Template generation for J750 Only

Tag: v0.2.0.dev7

Branch: ‘Trunk’
by Jiang Liu on 30-Sep-2014 00:13AM

Merged Priyavadan’s changes to latpc.atp for supporting linux ultra-flex pattern compiler. Added DCVS instrument import to ultra-flex patterns to allow for pattern run-time voltage switching via PSets.

Tag: v0.2.0.dev6

Branch: ‘Trunk’
by Cory Maughmer on 11-Aug-2014 19:22PM

-Added Teradyne UltraFLEX ATP compiler to plugin, found under /bin -Added ‘latpc’ as a shared command for use in applications. See rgen latpc -h for more help. Only compatible with UF tester -Use $tester.pattern_compiler_pinmap or the -p option at command line to specify the pinmap to use for compilation of .atp files -Compiles all .atp files in the default output directory by default. You can specify a different directory with the -dir option, and also list specific .atp files for compilation instead of the entire directory.

Tag: v0.2.0.dev5

Branch: ‘Trunk’
by Daniel Hadad on 18-Jul-2014 11:50AM

Changes in this release

  • Updated to use min rgen core v2.3.0.dev90 to support proper padding of UltraFLEX small patterns to 64 vector minimum.
  • Added capability to OR 2 flags together based on Test IDs. Now if flow you can do:
log '"Run testme only if passcode neither present in location A or location
B"'
func :check_locationA, continue: true, id: :locA
func :check_locationB, continue: true, id: :locB
nop
log '"OR to set a third master flag"'
# BE SURE to indicate condition (:pass/:fail) to align to where used below since no pass/fail column used
# need to deeper fix to handle automatically
or_ids id1: :locA, id2: :locB, id: :do_testme, condition: :pass
func :testme, if_passed: :do_testme  # will run only if do_testme is true--
which only will happen if both passcodes above fail.
  • Added more opcode cases for flag management.
  • Added :pattern_timeout as alias for :wait_time for J750 functional tests.

Known issues:

  • Running multiple targets back to back for program generation across different testers giving issue. Only impacts ‘rgen examples’ command but needs to be fixed soon.
  • Does not support proper placement of stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
  • Added concept of Pattern subroutine sheets to code– not yet fully supported.

Checkouts performed:

  • rgen examples

Features not yet supported:

  • Program Parsing
  • V93K support

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.2.0.dev4

Branch: ‘Trunk’
by Daniel Hadad on 23-Jun-2014 14:07PM

Changes in this release

  • Bugfix: Updated use-limit code to handle setting bins and other info properly for UltraFlex as before wouldn’t bin.

Known issues:

  • Running multiple targets back to back for program generation across different testers giving issue. Only impacts ‘rgen examples’ command but needs to be fixed soon.
  • Does not support proper placement of stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
  • Added concept of Pattern subroutine sheets to code– not yet fully supported.

Checkout performed:

  • rgen lint -e
  • rgen examples

Features not yet supported:

  • Program Parsing
  • V93K support
  • UF flows do not yet support ‘Use-Limit’ opcode in flow.

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.2.0.dev3

Branch: ‘Trunk’
by Jiang Liu on 08-May-2014 22:14PM

Messed up the ultraflex_interface.rb file on previous release, the use limit features are now correctly added, passing specs and examples.

Tag: v0.2.0.dev2

Branch: ‘Trunk’
by Jiang Liu on 08-May-2014 17:11PM

Added Use_limit in flow.rb Added aliases for hilim and lolim Added :use_limit for DEFAULTS in flow_line.rb Added conditioning to ALIASES.each.do Added alias_method for :para in j750_interface.rb Added test flow file for testing measurement capability using limits.

Tag: v0.2.0.dev1

Branch: ‘Trunk’
by Daniel Hadad on 11-Apr-2014 15:21PM

Changes in this release

  • UltraFlex templates added for Functional, Other and Empty.
  • Updated to support instance, patset and flows for UltraFlex.
  • Cleaned up code using new ‘rgen lint’ feature.

Known issues:

  • Running multiple targets back to back for program generation across different testers giving issue. Only impacts ‘rgen examples’ command but needs to be fixed soon.
  • Does not support proper placement of stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
  • Added concept of Pattern subroutine sheets to code– not yet fully supported.

Features not yet supported:

  • Program Parsing
  • V93K support
  • UF flows do not yet support ‘Use-Limit’ opcode in flow.

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.2.0.dev0

Branch: ‘Trunk’
by Daniel Hadad on 02-Apr-2014 15:23PM

Changes in this release

  • UF program generation capability added
  • References to tester templates corrected when accessed from app outside of plug-in.

Known issues:

  • Running multiple targets back to back for program generation across different testers giving issue. Only impacts ‘rgen examples’ command but needs to be fixed soon.

RGen Core Tester features supported and correlated thus far

J750 Pattern Generation

  • All patterns correlated except:
    • Does not support stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
    • Minor difference in match loop implementation (extra clr_fail when loop completed)

J750 Program Generation

  • All differences correlate

UltraFlex Program Generation

  • Can generate instancen, flow, patset sheets with proper header info.
  • Still not valid arguments and template types for UF.

UltraFlex Pattern Generation

  • Does not support stv on multi-cycle JTAG patterns yet
  • Match loops checked on tester!
  • Handshake methodology checked on tester!

RGen Core features not yet supported:

  • Program Parsing
  • V93K support

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.2.0

Branch: ‘Trunk’
by Daniel Hadad on 24-Mar-2014 16:33PM

Updated match loops for J750 and UltraFlex to count cycles of a block of code used for match conditions automatically, and adjust loops/counters accordingly.

Will very large timeout values:

  • For J750, max timeout = 2^32 * period * num_cycles_to_match
  • For UltraFLEX = 2^44 * period * num_cycles_to_match

Where num_cycles_to_match is number of cycles per match loop iteration, which includes delays to flush pipeline on each iteration.

E.G. for 60nS period UTI pattern on J750, max timeout => 158min E.G. for 60nS period UTI pattern on UltraFLEX, max timeout => 1116min E.G. for 250nS period Nexus pattern on J750, max timeout => 3758 min

For all purposes there is no limit.

For J750 match loop timeout is implemented using 2 16-bit counters nested.

For UltraFLEX match loop timeout is implemented using 1 28-bit counter with additional delay added via repeat count.

Tag: v0.1.0

Branch: ‘Trunk’
by Daniel Hadad on 14-Mar-2014 15:55PM

First semi-official release of Testers plug-in.

RGen Core features supported and correlated:

####J750 Pattern Generation

  • Does not support stv on multi-cycle JTAG patterns (neither does RGen core Tester class) yet
  • Minor difference in match loop implementation (extra clr_fail when loop completed)

J750 Program Generation

  • All differences correlate

UltraFlex Pattern Generation

  • Does not support stv on multi-cycle JTAG patterns yet
  • Improved UF support over RGen core Tester class
  • Match loops not yet checked on tester
  • Handshake methodology not yet checked on tester

RGen Core features not yet supported:

  • UltraFlex Program Generation
  • Program Parsing
  • V93K support

NOTE: Debugger ‘testers’ not included in this app, please see ‘Debuggers’ plug-in.

Tag: v0.0.0.dev2

Branch: ‘Trunk’
by Daniel Hadad on 03-Mar-2014 17:18PM

Added program generation capability for J750 and J750_HPT. Output matches against program generation examples from RGen core.

Updated ‘examples’ command to include both pattern and proggen checking capability.

Tag: v0.0.0.dev1

Branch: ‘Trunk’
by Daniel Hadad on 13-Feb-2014 10:55AM

Added vector padding capability if tester has fewer than some limit. Default is 0 (J750).

Mainly to support ultraflex which requires 64 min vectors for a VM module in single mode (128 in dual mode). Added reset pattern test to check this.

Tag: v0.0.0.dev0

Branch: ‘Trunk’
by Daniel Hadad on 10-Feb-2014 14:14PM

Initial release of Testers plug-in. Currently works only for pattern generation for J750 and J750_HPT testers. Will working to correlate all code aspects for J750/J750_HPT. ./


Comments