origen_std_lib 0.10.1 → 0.13.1

data/src/advantest/smt8/origen/test_methods/Functional_test.java

@@ -0,0 +1,474 @@
+package origen.test_methods;
+
+import java.util.ArrayList;
+import java.util.List;
+import origen.common.Origen;
+import origen.common.OrigenHelpers;
+import xoc.dsa.DeviceSetupFactory;
+import xoc.dsa.IDeviceSetup;
+import xoc.dta.datatypes.MultiSiteBoolean;
+import xoc.dta.datatypes.MultiSiteLong;
+import xoc.dta.datatypes.MultiSiteString;
+import xoc.dta.measurement.IMeasurement;
+import xoc.dta.resultaccess.IDigInOutCaptureResults;
+import xoc.dta.resultaccess.IMeasurementResult;
+import xoc.dta.resultaccess.datatypes.BitSequence.BitOrder;
+import xoc.dta.resultaccess.datatypes.MultiSiteBitSequence;
+import xoc.dta.setupaccess.IParallelGroup;
+import xoc.dta.testdescriptor.IFunctionalTestDescriptor;
+
+/** The Function test template for all functional tests */
+public class Functional_test extends Base {
+
+  public IFunctionalTestDescriptor FUNC;
+
+  // Class variables
+
+  /** Pin to capture from */
+  private String _pin;
+
+  /** Number of vectors to capture */
+  private int _capture;
+
+  /** Number of bits per captured word */
+  private int _bitPerWord;
+
+  /** Pattern name */
+  @SuppressWarnings("unused")
+  private String _pattern;
+
+  /** Testname to override */
+  @SuppressWarnings("unused")
+  private String _testNameOverride;
+
+  /** The result of executing the primary pattern */
+  public IMeasurementResult funcResult;
+
+  private MultiSiteBitSequence _capturedData;
+
+  // Link to self
+  public Functional_test origen;
+
+  // Patching information
+  /** Do we need to activate the patched patterns? */
+  boolean activatePatchedMeas;
+
+  /** The measurement that is only used for patching */
+  public IMeasurement patchedMeas;
+
+  /** The measurement that is only used dynamic pattern switching */
+  public IMeasurement dynamicPatMeas;
+
+  public ArrayList<IMeasurementResult> dynamicMeasurementResults;
+
+  public boolean _hasDynamicMeas = false;
+
+  /** The list of patterns to patch */
+  List<String> patchList;
+
+  /** Used to select only one pattern from a list of patterns for site specific execution */
+  List<String> dynamicPatternList;
+
+  @Override
+  public void _setup() {
+    message(Origen.LOG_METHODTRACE, "Functional_test --> Setup");
+    origen = this;
+    patchList = new ArrayList<String>();
+    dynamicPatternList = new ArrayList<String>();
+    patchedMeas.setSpecificationName(measurement.getSpecificationName());
+    dynamicPatMeas.setSpecificationName(measurement.getSpecificationName());
+    pin("");
+    capture(0);
+    bitPerWord(1);
+    pattern("");
+    testName("");
+
+    measure_setup();
+  }
+
+  /**
+   * Creates/adds to a list of patched patterns Needs to be called for every pattern that has to be
+   * patched
+   *
+   * @param pat
+   * @return
+   */
+  public Functional_test addToPatchList(String pat) {
+
+    patchList.add("C402TNVMTester.patterns." + pat);
+    return this;
+  }
+
+  public Functional_test addToDynamicPatternList(String pat) {
+    dynamicPatternList.add(pat);
+    return this;
+  }
+
+  public Functional_test overlaySubroutinePerSite(
+      String subroutinePattern, MultiSiteLong decData, int size) {
+    Origen.overlaySubroutinePerSite(
+        "C402TNVMTester.patterns." + subroutinePattern, "NVM_DIN_PIN", decData, size);
+    return this;
+  }
+
+  //overload for full path pattern. Boolean not used at the moment
+  public Functional_test overlaySubroutinePerSite(String subroutinePattern,
+          MultiSiteLong decData, String pin, int size, Boolean FullPathPattern ) {
+    Origen.overlaySubroutinePerSite(subroutinePattern, pin, decData, size);
+    return this;
+  }
+
+  public Functional_test overlaySubroutineAllSites(
+      String subroutinePattern, long decData, int size) {
+    Origen.overlaySubroutineAllSites(
+        "C402TNVMTester.patterns." + subroutinePattern, "NVM_DIN_PIN", decData, size);
+    return this;
+  }
+
+  //overload for full path pattern. Boolean not used at the moment
+  public Functional_test overlaySubroutineAllSites(String subroutinePattern, long decData, String pin, int size, Boolean FullPathPattern) {
+      Origen.overlaySubroutineAllSites(subroutinePattern, pin, decData, size);
+      return this;
+  }
+
+  /**
+   * Setup the patch measurement instance Call after all patterns are added to the list The setup
+   * creates a new devicesetup with fake pattern calls to all patched patterns This make sure that
+   * they are referenced in this testmethod. Is is not possible to patch patterns that are not used
+   * in the testflow After this setupPatch() is called, the patchedMeas still needs to be activated,
+   * this happens in run()
+   *
+   * @return
+   */
+  public Functional_test setupPatch() {
+    IDeviceSetup ds = DeviceSetupFactory.createInstance();
+    ds.importSpec(measurement.getSpecificationName());
+    ds.sequentialBegin("measPatch");
+    {
+      for (String pat : patchList) {
+        ds.patternCall(pat);
+      }
+    }
+    ds.sequentialEnd();
+    patchedMeas.setSetups(ds);
+
+    // Warn run() that we need to activate the patched measurement still
+    activatePatchedMeas = true;
+
+    return this;
+  }
+
+  public Functional_test setupDynamicPatternList() {
+    IDeviceSetup ds = DeviceSetupFactory.createInstance();
+    ds.importSpec(dynamicPatMeas.getSpecificationName());
+    for (String pat : dynamicPatternList) {
+      ds.parallelBegin(pat);
+      {
+        ds.setBypassable();
+        ds.patternCall("C402TNVMTester.patterns." + pat);
+      }
+      ds.parallelEnd();
+    }
+    dynamicPatMeas.setSetups(ds);
+    _hasDynamicMeas = true;
+    return this;
+  }
+
+  // Executed the given (previously setup) pattern on all sites
+  public void executeDynamicPat(String pat) {
+    selectDynamicPat(pat);
+    dynamicPatMeas.execute();
+    dynamicMeasurementResults.add(dynamicPatMeas.preserveResult());
+  }
+
+  // Execute the given (previously setup) pattern on all sites except those where bypass is set to
+  // true
+  public void executeDynamicPat(String pat, MultiSiteBoolean bypass) {
+    selectDynamicPat(pat, bypass);
+    dynamicPatMeas.execute();
+    dynamicMeasurementResults.add(dynamicPatMeas.preserveResult());
+  }
+
+  // Executed the given (previously setup) patterns on all sites, where each site can have a
+  // different pattern
+  public void executeDynamicPat(MultiSiteString pats) {
+    selectDynamicPats(pats);
+    dynamicPatMeas.execute();
+    dynamicMeasurementResults.add(dynamicPatMeas.preserveResult());
+  }
+
+  public Functional_test selectDynamicPat(String pat, MultiSiteBoolean bypass) {
+    message(Origen.LOG_METHODTRACE, "Executing dynamic pattern: " + pat);
+    boolean patFound = false;
+    MultiSiteBoolean allSites = new MultiSiteBoolean(true);
+    List<IParallelGroup> paraGroups = dynamicPatMeas.operatingSequence().getParallelGroups();
+    for (IParallelGroup iParallelGroup : paraGroups) {
+      if (iParallelGroup.getName().equals(pat)) {
+        patFound = true;
+        iParallelGroup.setBypass(bypass);
+      } else {
+        iParallelGroup.setBypass(allSites);
+      }
+    }
+    if (!patFound) {
+      throw new Error(
+          "Dynamic pattern: " + pat + " not found!! Make sure you have it added in setup()");
+    }
+    return this;
+  }
+
+  public Functional_test selectDynamicPat(String pat) {
+    MultiSiteBoolean noSites = new MultiSiteBoolean(false);
+    selectDynamicPat(pat, noSites);
+    return this;
+  }
+
+  public Functional_test selectDynamicPats(MultiSiteString pats) {
+    //        boolean patFound = false;
+
+    List<IParallelGroup> paraGroups = dynamicPatMeas.operatingSequence().getParallelGroups();
+    for (IParallelGroup iParallelGroup : paraGroups) {
+      MultiSiteBoolean bypass = new MultiSiteBoolean(true);
+      for (int site : context.getActiveSites()) {
+        if (iParallelGroup.getName().equals(pats.get(site))) {
+          bypass.set(site, false);
+        }
+      }
+      iParallelGroup.setBypass(bypass);
+    }
+    //        if(!patFound)  {
+    //            throw new Error("Dynamic pattern: " + pat + " not found!! Make sure you have it
+    // added in setup()");
+    //        }
+    return this;
+  }
+
+  /**
+   * The functional test method can optionally capture data by supplying the number of vectors to
+   * capture
+   *
+   * @param v Number of vectors to capture
+   * @return
+   */
+  public Functional_test capture(int numVecs) {
+    _capture = numVecs;
+    return this;
+  }
+
+  /**
+   * If data capture is requested, supply the pin to capture data from
+   *
+   * @param pin Pin to capture from
+   * @return
+   */
+  public Functional_test pin(String pin) {
+    _pin = pin;
+    return this;
+  }
+
+  /**
+   * Serial capture data will be grouped into words, specify how many bits per word in the serial
+   * stream (default 1)
+   *
+   * @param bitsPerWord
+   * @return
+   */
+  public Functional_test bitPerWord(int bitsPerWord) {
+    _bitPerWord = bitsPerWord;
+    return this;
+  }
+
+  /**
+   * Override the pattern argument from the test suite
+   *
+   * @param patName
+   * @return
+   */
+  public Functional_test pattern(String patName) {
+    _pattern = patName;
+    return this;
+  }
+
+  /**
+   * Override the test name argument from the test suite, this can be useful if the main test item
+   * to be logged is a captured value and the pattern execution is to be logged separately. The
+   * override is only valid for one call to execute()
+   *
+   * @param testName
+   * @return
+   */
+  public Functional_test testName(String newTestName) {
+    _testNameOverride = newTestName;
+    return this;
+  }
+
+  /**
+   * Gets all captured data
+   *
+   * @return
+   */
+  public MultiSiteBitSequence capturedData() {
+    return _capturedData;
+  }
+
+  /**
+   * Gets a specific word from the captured data Bitorder is fixed to RIGHT_TO_LEFT
+   *
+   * @param wordNr
+   * @return
+   */
+  public MultiSiteLong capturedData(int wordNr) {
+    message(Origen.LOG_METHODTRACE, "Get captured data" + wordNr);
+    return capturedData(wordNr, BitOrder.RIGHT_TO_LEFT);
+  }
+
+  /**
+   * Gets a specific word from the captured data Bitorder has to be specified
+   *
+   * @param wordNr
+   * @param order BitOrder (eg. RIGHT_TO_LEFT)
+   * @return
+   */
+  public MultiSiteLong capturedData(int wordNr, BitOrder order) {
+    // Init the MultiSite array
+    MultiSiteLong MSL = new MultiSiteLong();
+
+    // Loop through the sites to get the data
+    for (int site : context.getActiveSites()) {
+      message(
+          Origen.LOG_METHODTRACE,
+          "Num cap words: " + _capturedData.get(site).toLongArray(_bitPerWord, order).length);
+      MSL.set(site, _capturedData.get(site).toLongArray(_bitPerWord, order)[wordNr]);
+    }
+    return MSL;
+  }
+
+  /**
+   * Gives the string representation of the binary sequence of the result data for a specific wordnr
+   * Bitorder is fixed to RIGHT_TO_LEFT
+   *
+   * @param wordNr
+   * @return
+   */
+  public MultiSiteString getBinaryWord(int wordNr) {
+    MultiSiteString MSS = new MultiSiteString();
+    for (int site : context.getActiveSites()) {
+      MSS.set(
+          site,
+          OrigenHelpers.longToPaddedBinaryString(
+              _capturedData.get(site).toLongArray(_bitPerWord, BitOrder.RIGHT_TO_LEFT)[wordNr],
+              _bitPerWord,
+              BitOrder.RIGHT_TO_LEFT,
+              false));
+    }
+    return MSS;
+  }
+
+  /**
+   * Gives the string representation of the HEX sequence of the result data for a specific wordnr
+   * Bitorder is fixed to RIGHT_TO_LEFT
+   *
+   * @param wordNr
+   * @return
+   */
+  public MultiSiteString getHexWord(int wordNr, int nrHexChars) {
+    MultiSiteString MSS = new MultiSiteString();
+    for (int site : context.getActiveSites()) {
+      MSS.set(
+          site,
+          OrigenHelpers.longToPaddedHexString(
+              _capturedData.get(site).toLongArray(_bitPerWord, BitOrder.RIGHT_TO_LEFT)[wordNr],
+              nrHexChars,
+              BitOrder.RIGHT_TO_LEFT));
+    }
+    return MSS;
+  }
+
+  /** Helper function for default bitPerWord use */
+  public MultiSiteString getHexWord(int wordNr) {
+    return getHexWord(wordNr, _bitPerWord / 4);
+  }
+
+  @Override
+  public void _preBody() {
+    dynamicMeasurementResults = new ArrayList<IMeasurementResult>();
+  }
+
+  /** Main run function for functional */
+  @SuppressWarnings("null")
+  @Override
+  public void run() {
+    IDigInOutCaptureResults digCapture = null;
+
+    logTrace("Functional_test", "run");
+    super.run();
+
+//  TODO - EP - with SMT 8.2.3 - xoc.dta.UncheckedDTAException: Pattern can only be set in setup().
+    // Check if we need to override the pattern name
+//    if (_pattern != "") {
+//      measurement.setPatternName(_pattern);
+//    }
+
+    // Check if we need to capture anything
+    // When capture is enabled, we have to disable the cyclePassFail
+    if (_capture > 0) {
+      logTrace("Functional_test", "Enabling capture on " + _pin);
+      measurement.digInOut(_pin).result().cyclePassFail().setEnabled(false);
+      measurement.digInOut(_pin).result().capture().setEnabled(true);
+    } else {
+      logTrace("Functional_test", "Disabling capture on " + _pin);
+      measurement.digInOut(_pin).result().cyclePassFail().setEnabled(true);
+      measurement.digInOut(_pin).result().capture().setEnabled(false);
+    }
+
+    // Run the measurement
+    measurement.execute();
+
+    funcResult = measurement.preserveResult();
+
+    // When captured was enabled, we need to load the captured data for later processing
+    // After this is done, the tester can be released
+    if (_capture > 0) {
+      // protect results to be not overwritten
+      digCapture = measurement.digInOut(_pin).preserveCaptureResults();
+    }
+
+    // Activate the patched measurements
+    // Without this, you cannot patch any patterns that are not used in THIS testmethod
+    if (activatePatchedMeas) {
+      patchedMeas.activate();
+    }
+
+    // Assume for now that if force pass is set then branching decision could be dependent on the
+    // result of this test, in future add another attribute to control async processing on/off
+    if (!syncPar && !forcePass) {
+      releaseTester();
+    }
+
+    if (_capture > 0) {
+      _capturedData =
+          digCapture.getSerialBitsAsBitSequence(measurement.getSignal(_pin).getDutSignalName());
+    }
+  }
+
+  @Override
+  public void processResults() {
+    logTrace("Functional_test", "processResults");
+
+    if (_hasDynamicMeas && dynamicMeasurementResults.size() > 0) {
+      MultiSiteBoolean dynamicPassed = new MultiSiteBoolean(dynamicMeasurementResults.get(0).hasPassed());
+      for (IMeasurementResult result : dynamicMeasurementResults) {
+              dynamicPassed = dynamicPassed.and(result.hasPassed());
+      }
+      if (funcResult != null) {
+        judgeAndDatalog(FUNC, dynamicPassed.and(funcResult.hasPassed()));
+      } else {
+        judgeAndDatalog(FUNC, dynamicPassed);
+      }
+    } else {
+      if (funcResult != null) {
+        judgeAndDatalog(FUNC, funcResult);
+      }
+    }
+  }
+}

data/templates/web/faq.md.erb

@@ -54,7 +54,7 @@ Not officially. It is open source and comes with no guarantees.
 
 #### So who does support it then?
 
-Right now the Origen core team (who are mainly all NXP employees today, but we hope that will change),
+Right now the Origen core team (comprising engineers from NXP and AMD)
 are the primary
 maintainers and we will consider feature requests and address bug reports that are submitted by users
 of the library.
@@ -63,55 +63,4 @@ However anyone is more then welcome to contribute bug fixes, feature additions,
 documentation, etc. and ultimately we hope to see a self-sustaining community grow around
 this project.
 
-#### What platforms do you intend to support?
-
-Initially we are developing this as an offshoot of some new test programs we are making for
-the Advantest V93K platform.
-
-We do expect to start to adding similar features for Teradyne platforms (likely J570 and UltraFLEX)
-next year.
-
-## V93K Specific
-
-#### Why do we need this?
-
-The standard test method library that comes with SmarTest for AC and DC tests, is no longer
-recommended by Advantest.
-
-However, while its replacement (RDI) is a high-level API in terms of the tester hardware, it is
-still a low level
-API in terms of a complete test. Anyone who wants to implement even a basic test, has
-to write a custom test method from scratch instead of just picking up an existing test
-method off the shelf.
-
-This project aims to fill that void and provide a modern library of off-the-shelf test
-methods that adhere to the latest Advantest guidelines.
-
-#### I will probably still need some custom tests, can this help with those?
-
-Yes. The off-the-shelf test methods provided by this library are very thin wrappers around
-a high level Origen API, which implements high level functions such as "run a functional test",
-"run a pattern and take a DC measurement", etc.
-Each of these functions provides a standard set of callback points so that your test program can easily
-hook into their execution in order to add your own customizations.
-
-Additionally, as well as complete test methods, this project also aims to provide a rich
-library of helper functions
-that can be used when writing your own tests.
-
-#### Does it perform well?
-
-Yes. It uses the latest RDI APIs recommended by Advantest under the hood and it will in future
-fully support background data-processing using the SmartCalc framework.
-
-#### Why is the library not installed at system level?
-
-We want to encourage the users of the library to look inside it, so that they can begin to understand
-it, be empowered to do front line debug, and be able to experiment with adding new features.
-Distributing it as a binary for installation at system level would add a significant barrier
-to the open and inclusive way of working that we want to encourage.
-
-Installing it within the test program itself also makes the test programs self contained and
-therefore more portable between test systems.
-
 % end

data/templates/web/guides/intro.md.erb

@@ -0,0 +1,8 @@
+% render "templates/web/layouts/guides.html" do
+
+These guides are organized by ATE platform, select the one you are interested in:
+
+* [Advantest V93K SMT7](<%= path 'guides/v93ksmt7/intro' %>)
+* [Advantest V93K SMT8](<%= path 'guides/v93ksmt8/intro' %>)
+
+% end

data/templates/web/guides/{v93k/intro.md.erb → v93ksmt7/capture.md.erb}

@@ -1,5 +1,3 @@
 % render "templates/web/layouts/guides.html" do
 
-Hello 
-
 % end

data/templates/web/guides/v93ksmt7/complete.md.erb

@@ -0,0 +1,68 @@
+% render "templates/web/layouts/guides.html" do
+
+The following complete test methods are provided to be directly called from a test suite:
+
+* [FunctionalTest](#Functional_Test)
+* [DCMeasurement](#DCMeasurement)
+* [FrequencyMeasurement](#FrequencyMeasurement)
+
+### FunctionalTest
+
+This test will simply execute the pattern (label) defined by the test suite and will set pass/fail
+depending on whether any mis-compares occur during the pattern execution.
+
+#### Arguments
+
+<%= render "partials/common_args.md.erb", preserve_target: true %>
+
+### DCMeasurement
+
+This test will execute the pattern (label) defined by the test suite and then perform a voltage or
+current measurement on the given pin.
+
+Options exist to configure the measurement and to select whether or not to run a shutdown pattern
+after the measurement has been taken.
+
+
+#### Arguments
+
+* **pin (string)** - (**Required**) The name of the pin to be measured.
+* **measure (string)** - (Optional, Default="VOLT") Define whether to measure current or voltage (the default).
+  Set to "CURR" to measure current.
+* **settlingTime (double)** - (Optional, Default=0) Specify the time to wait after running the pattern before
+  taking the measurement, expressed in ms.
+* **forceValue (double)** - (Optional, Default=0) The value to be forced on the pin during the measurement.
+* **iRange (double)** - (Optional, Default=0) The current range to apply to the measurement in amps, it will
+  be calculated if not supplied (set to 0).
+* **badc (integer)** - (Optional, Default=0) When set to 1 the measurement will be made using the board ADC
+  rather than the PPMU (the default)
+* **applyShutdown (integer)** - (Optional, Default=1) Set to 1 to execute the pattern (label) defined
+  by the `shutdownPattern` argument after the measurement.
+* **shutdownPattern (string)** - (Optional, Default="<PATTERN>_part1") The name of the pattern (label) to be executed after taking
+  the measurement, this argument is required if `applyShutdown` is set to 1. By default it will look for a pattern
+  named after the main pattern (label) with "_part1" appended.
+* **checkShutdown (integer)** - (Optional, Default=1) When set to 1 the executing of the shutdown pattern
+  will be cared and the overall test will fail if any miscompares occur during the shutdown patten execution.
+<%= render "partials/common_args.md.erb", preserve_target: true %>
+
+### FrequencyMeasurement
+
+Measure the frequency of a clock being output on the given pin.
+
+The pattern run by this test must setup the device to output the clock on the given pin
+and then run additional cycles where the data on the pin under test is digitally captured.
+
+The period of the capture cycles must be less than that of the clock being measured.
+The effect of different settings of the capture period and the number of capture cycles should be
+characterized to determine the optimal settings to meet the application's particular accuracy and
+test time goals.
+
+* **pin (string)** - (**Required**) The name of the pin to be measured.
+* **periodInNs (integer)** - (**Required**) The period of the pattern's capture vectors.
+* **samples (integer)** - (Optional, Default=2000) The number of digital capture cycles made by the
+  pattern.
+* **periodBased (integer)** - (Optional, Default=0) Set to 1 if the test limits are expressed as a
+  period instead of a frequency (the default).
+<%= render "partials/common_args.md.erb", preserve_target: true %>
+
+% end