origen_std_lib 0.10.1 → 0.13.1

data/src/advantest/smt7/origen/origen/test_method/base.hpp

@@ -0,0 +1,155 @@
+#ifndef ORIGEN_TEST_METHOD_BASE_INCLUDED
+#define ORIGEN_TEST_METHOD_BASE_INCLUDED
+
+#include "../../origen.hpp"
+#include "../test_method.hpp"
+#include "mapi.hpp"
+#include "testmethod.hpp"
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+class Base : public testmethod::TestMethod {
+  bool _async;
+  bool _syncup;
+
+ public:
+  Base();
+  virtual ~Base();
+
+  Base& async(bool v) {
+    _async = v;
+    return *this;
+  }
+  Base& syncup(bool v) {
+    _syncup = v;
+    return *this;
+  }
+
+  void execute() { _execute(); }
+
+  virtual void SMC_backgroundProcessing(){};
+
+ protected:
+  int numberOfPhysicalSites;
+  ARRAY_I activeSites;
+  string suiteName;
+  bool bFirstRun;
+
+  string _testName;
+  int _forcePass;
+  string _onPassFlag;
+  string _onFailFlag;
+
+  int offline();
+  void initialize();
+  void run();
+  int testNumber();
+  int testNumber(string);
+  TMLimits::LimitInfo testLimits();
+  TMLimits::LimitInfo testLimits(string);
+  void datalog(double);
+  void datalog(string, double);
+  void judgeAndDatalog(double);
+  void judgeAndDatalog(string, double);
+  bool preJudge(double);
+  bool preJudge(string, double);
+  string testName();
+  int invertFunctionalResultIfRequired(int);
+  bool isWithinLimits(double, LIMIT);
+  LIMIT toNALimit(LIMIT);
+  vector<int> suiteFailed;
+
+  virtual void init() {}
+
+  /// For internal use, don't override
+  virtual void _setup() {}
+
+  // Called immediately before the first RDI operation is executed
+  virtual void preBody() {}
+  virtual void preBody(int site) {}
+
+  virtual void body() { execute(); }
+
+  virtual void _execute() {}
+
+  // Called before the main RDI operation is executed, giving the chance to add
+  // additional settings to it
+  virtual void filterRDI(SMART_RDI::dcBase& prdi) {}
+  virtual void filterRDI(SMART_RDI::DIG_CAP& prdi) {}
+  virtual void filterRDI(SMART_RDI::FUNC& prdi) {}
+
+  // If the test has a hold state, this will be called immediately after the
+  // hold
+  // state pattern has run
+  virtual void holdState() {}
+  virtual void holdState(int site) {}
+
+  // Called after the last RDI operation has executed and all results have been
+  // fetched
+  virtual void postBody() {}
+  virtual void postBody(int site) {}
+
+  // Called immediately before the final result processing. If the test is
+  // configured for async
+  // processing then this will be called later in the background. Contrast this
+  // with the
+  // postTestFunc which will be called before the main test body completes.
+  virtual void process(int site) {}
+
+  // Called before the main test result is judged, giving a chance to transform
+  // it
+  virtual double filterResult(double result) { return result; }
+
+  virtual bool async() { return _async; }
+  virtual bool syncup() { return _syncup; }
+
+  virtual void serialProcessing(int site){};
+
+  void enableHiddenUpload() {
+    if (async()) {
+      rdi.hiddenUpload(TA::ALL);
+    } else {
+      rdi.hiddenUpload(TA::NO);
+    }
+  }
+
+  void callPreBody() {
+    if (syncup()) {
+      synchronize();
+    }
+    preBody();
+    FOR_EACH_SITE_BEGIN();
+    preBody(CURRENT_SITE_NUMBER());
+    FOR_EACH_SITE_END();
+  }
+
+  void callHoldState() {
+    holdState();
+    FOR_EACH_SITE_BEGIN();
+    holdState(CURRENT_SITE_NUMBER());
+    FOR_EACH_SITE_END();
+  }
+
+  template <class T>
+  void callPostBody(T* obj) {
+    ON_FIRST_INVOCATION_BEGIN();
+    postBody();
+    FOR_EACH_SITE_BEGIN();
+    postBody(CURRENT_SITE_NUMBER());
+    FOR_EACH_SITE_END();
+    ON_FIRST_INVOCATION_END();
+
+    if (async()) {
+      SMC_ARM_internal(obj);
+    } else {
+      process(CURRENT_SITE_NUMBER());
+      this->serialProcessing(CURRENT_SITE_NUMBER());
+    }
+  }
+};
+}
+}
+
+#endif /* BASE_HPP_ */

data/src/advantest/smt7/origen/origen/test_method/dc_measurement.cpp

@@ -0,0 +1,266 @@
+#include "dc_measurement.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+// Defaults
+DCMeasurement::DCMeasurement() {
+  applyShutdown(1);
+  checkShutdown(1);
+  measure("VOLT");
+  settlingTime(0);
+  forceValue(0);
+  iRange(0);
+  processResults(1);
+  badc(0);
+  port("");
+}
+
+DCMeasurement::~DCMeasurement() {}
+
+DCMeasurement& DCMeasurement::applyShutdown(int v) {
+  _applyShutdown = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::shutdownPattern(string v) {
+  _shutdownPattern = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::checkShutdown(int v) {
+  _checkShutdown = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::measure(string v) {
+  _measure = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::settlingTime(double v) {
+  _settlingTime = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::pin(string v) {
+  _pin = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::port(string v) {
+  _port = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::forceValue(double v) {
+  _forceValue = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::iRange(double v) {
+  _iRange = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::processResults(int v) {
+  _processResults = v;
+  return *this;
+}
+DCMeasurement& DCMeasurement::badc(int v) {
+  _badc = v;
+  return *this;
+}
+
+// All test methods must implement this function
+DCMeasurement& DCMeasurement::getThis() { return *this; }
+
+void DCMeasurement::_setup() {
+  pin(extractPinsFromGroup(_pin));
+  results.resize(numberOfPhysicalSites + 1);
+  funcResultsPre.resize(numberOfPhysicalSites + 1);
+  funcResultsPost.resize(numberOfPhysicalSites + 1);
+  label = Primary.getLabel();
+}
+
+void DCMeasurement::_execute() {
+  int site;
+
+  ON_FIRST_INVOCATION_BEGIN();
+
+  if (_applyShutdown) {
+    if (_shutdownPattern.empty()) {
+      ostringstream pat;
+      pat << label << "_part1";
+      shutdownPattern(pat.str());
+    }
+  }
+
+  if (!_iRange && _measure == "CURR") {
+    double dHigh(0), dLow(0);
+    TM::COMPARE cHigh, cLow;
+    testLimits().TEST_API_LIMIT.get(cLow, dLow, cHigh, dHigh);
+
+    if (cLow == TM::NA) {
+      dLow = 0;
+    }
+    if (cHigh == TM::NA) {
+      dHigh = 0;
+    }
+
+    if (dLow == 0 && dHigh == 0) {
+      cout << "ERROR: If your current measurement does not have a limit, you "
+              "must supply the current range"
+           << endl;
+      ERROR_EXIT(TM::ABORT_FLOW);
+    }
+    if (abs(dLow) > abs(dHigh)) {
+      _iRange = abs(dLow);
+    } else {
+      _iRange = abs(dHigh);
+    }
+  }
+
+  RDI_BEGIN();
+
+  if (_port.empty()) {
+    rdi.func(suiteName + "f1").label(label).execute();
+  } else {
+    rdi.port(_port).func(suiteName + "f1").burst(label).execute();
+  }
+
+  callHoldState();
+
+  if (_measure == "VOLT") {
+    if (_badc) {
+      if (_port.empty()) {
+        rdi.dc(suiteName)
+            .pin(_pin, TA::BADC)
+            .measWait(_settlingTime)
+            .vMeas()
+            .execute();
+      } else {
+        rdi.port(_port)
+            .dc(suiteName)
+            .pin(_pin, TA::BADC)
+            .measWait(_settlingTime)
+            .vMeas()
+            .execute();
+      }
+
+    } else {
+      if (_port.empty()) {
+        SMART_RDI::dcBase& prdi =
+            rdi.dc(suiteName)
+                .pin(_pin)
+                .iForce(_forceValue)
+                .measWait(_settlingTime)
+                .relay(TA::ppmuRly_onPPMU_offACDC, TA::ppmuRly_onAC_offDCPPMU)
+                .vMeas();
+        filterRDI(prdi);
+        prdi.execute();
+      } else {
+        SMART_RDI::dcBase& prdi =
+            rdi.port(_port)
+                .dc(suiteName)
+                .pin(_pin)
+                .iForce(_forceValue)
+                .measWait(_settlingTime)
+                .relay(TA::ppmuRly_onPPMU_offACDC, TA::ppmuRly_onAC_offDCPPMU)
+                .vMeas();
+        filterRDI(prdi);
+        prdi.execute();
+      }
+    }
+
+  } else {
+    if (_port.empty()) {
+      SMART_RDI::dcBase& prdi =
+          rdi.dc(suiteName)
+              .pin(_pin)
+              .vForce(_forceValue)
+              .relay(TA::ppmuRly_onPPMU_offACDC, TA::ppmuRly_onAC_offDCPPMU)
+              .measWait(_settlingTime)
+              .iRange(_iRange)
+              .iMeas();
+
+      filterRDI(prdi);
+      prdi.execute();
+    } else {
+      SMART_RDI::dcBase& prdi =
+          rdi.port(_port)
+              .dc(suiteName)
+              .pin(_pin)
+              .vForce(_forceValue)
+              .relay(TA::ppmuRly_onPPMU_offACDC, TA::ppmuRly_onAC_offDCPPMU)
+              .measWait(_settlingTime)
+              .iRange(_iRange)
+              .iMeas();
+
+      filterRDI(prdi);
+      prdi.execute();
+    }
+  }
+
+  if (_applyShutdown) {
+    if (_port.empty()) {
+      rdi.func(suiteName + "f2").label(_shutdownPattern).execute();
+    } else {
+      rdi.port(_port).func(suiteName + "f2").burst(_shutdownPattern).execute();
+    }
+  }
+
+  RDI_END();
+
+  FOR_EACH_SITE_BEGIN();
+  site = CURRENT_SITE_NUMBER();
+  funcResultsPre[site] = rdi.id(suiteName + "f1").getPassFail();
+  if (_applyShutdown)
+    funcResultsPost[site] = rdi.id(suiteName + "f2").getPassFail();
+  // TODO: This retrieval needs to move to the SMC func in the async case
+  if (offline()) {
+    double dHigh(0), dLow(0);
+    TM::COMPARE cHigh, cLow;
+    testLimits().TEST_API_LIMIT.get(cLow, dLow, cHigh, dHigh);
+
+    if (cLow != TM::NA && cHigh != TM::NA) {
+      results[site] = ((dHigh - dLow) / 2) + dLow;
+    } else if (cLow != TM::NA) {
+      results[site] = dLow;
+    } else if (cHigh != TM::NA) {
+      results[site] = dHigh;
+    } else {
+      results[site] = 0;
+    }
+
+  } else {
+    results[site] = rdi.id(suiteName).getValue();
+  }
+
+  FOR_EACH_SITE_END();
+
+  ON_FIRST_INVOCATION_END();
+}
+
+void DCMeasurement::serialProcessing(int site) {
+  if (_processResults) {
+    judgeAndDatalog(testName() + "_FUNCPRE",
+                    invertFunctionalResultIfRequired(funcResultsPre[site]));
+
+    judgeAndDatalog(testName(), filterResult(results[site]));
+
+    if (_applyShutdown && _checkShutdown) {
+      judgeAndDatalog(testName() + "_FUNCPOST",
+                      invertFunctionalResultIfRequired(funcResultsPost[site]));
+    }
+  }
+}
+
+void DCMeasurement::SMC_backgroundProcessing() {
+  for (int i = 0; i < activeSites.size(); i++) {
+    int site = activeSites[i];
+    process(site);
+    if (_processResults) {
+      SMC_TEST(site, "", suiteName, LIMIT(TM::GE, 1, TM::LE, 1),
+               funcResultsPre[site]);
+      if (_applyShutdown && _checkShutdown)
+        SMC_TEST(site, "", suiteName, LIMIT(TM::GE, 1, TM::LE, 1),
+                 funcResultsPost[site]);
+      SMC_TEST(site, _pin, suiteName, testLimits().TEST_API_LIMIT,
+               filterResult(results[site]));
+    }
+  }
+}
+}
+}

data/src/advantest/smt7/origen/origen/test_method/dc_measurement.hpp

@@ -0,0 +1,58 @@
+#ifndef ORIGEN_TEST_METHOD_DC_MEASUREMENT_INCLUDED
+#define ORIGEN_TEST_METHOD_DC_MEASUREMENT_INCLUDED
+
+#include "base.hpp"
+#include "mapi.hpp"
+#include "rdi.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+class DCMeasurement : public Base {
+  void serialProcessing(int site);
+
+  int _applyShutdown;
+  string _shutdownPattern;
+  int _checkShutdown;
+  string _measure;
+  double _settlingTime;
+  string _pin;
+  string _port;
+  double _forceValue;
+  double _iRange;
+  int _processResults;
+  int _badc;
+
+ public:
+  DCMeasurement();
+  virtual ~DCMeasurement();
+  void SMC_backgroundProcessing();
+
+  DCMeasurement& applyShutdown(int v);
+  DCMeasurement& shutdownPattern(string v);
+  DCMeasurement& checkShutdown(int v);
+  DCMeasurement& measure(string v);
+  DCMeasurement& settlingTime(double v);
+  DCMeasurement& pin(string v);
+  DCMeasurement& port(string v);
+  DCMeasurement& forceValue(double v);
+  DCMeasurement& iRange(double v);
+  DCMeasurement& processResults(int v);
+  DCMeasurement& badc(int v);
+
+ protected:
+  typedef DCMeasurement super;
+  DCMeasurement& getThis();
+  void _setup();
+  void _execute();
+
+  string label;
+  vector<int> funcResultsPre;
+  vector<int> funcResultsPost;
+  vector<double> results;
+};
+}
+}
+#endif

data/src/advantest/smt7/origen/origen/test_method/empty.cpp

@@ -0,0 +1,13 @@
+#include "empty.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+Empty::Empty() {}
+
+Empty::~Empty() {}
+
+// All test methods must implement this function
+Empty& Empty::getThis() { return *this; }
+}
+}

data/src/advantest/smt7/origen/origen/test_method/empty.hpp

@@ -0,0 +1,24 @@
+#ifndef ORIGEN_TEST_METHOD_FUNCTIONAL_TEST_INCLUDED
+#define ORIGEN_TEST_METHOD_FUNCTIONAL_TEST_INCLUDED
+
+#include "base.hpp"
+#include "mapi.hpp"
+#include "rdi.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+class Empty : public Base {
+ public:
+  Empty();
+  virtual ~Empty();
+
+ protected:
+  typedef Empty super;
+  Empty& getThis();
+};
+}
+}
+#endif

data/src/advantest/smt7/origen/origen/test_method/frequency_measurement.cpp

@@ -0,0 +1,133 @@
+#include "frequency_measurement.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+// Defaults
+FrequencyMeasurement::FrequencyMeasurement() {
+  samples(2000);
+  processResults(1);
+  port("");
+}
+FrequencyMeasurement::~FrequencyMeasurement() {}
+
+/// By default the limits are assumed to be expressed as a frequency, set this
+/// to 1 if they refer to a target period
+FrequencyMeasurement& FrequencyMeasurement::periodBased(int v) {
+  _periodBased = v;
+  return *this;
+}
+/// REQUIRED: The name of the pin being measured
+FrequencyMeasurement& FrequencyMeasurement::pin(string v) {
+  _pin = v;
+  return *this;
+}
+/// Optionally supply the name of the test port that should be used to execute
+/// the pattern
+FrequencyMeasurement& FrequencyMeasurement::port(string v) {
+  _port = v;
+  return *this;
+}
+/// The number of samples captured by the pattern, the default is 2000
+FrequencyMeasurement& FrequencyMeasurement::samples(int v) {
+  _samples = v;
+  return *this;
+}
+/// REQUIRED: Supply the period of the captured vectors in nanoseconds
+FrequencyMeasurement& FrequencyMeasurement::periodInNs(int v) {
+  _periodInNs = v;
+  return *this;
+}
+/// When set to 0 the results of the test will not be judged or logged
+FrequencyMeasurement& FrequencyMeasurement::processResults(int v) {
+  _processResults = v;
+  return *this;
+}
+
+// All test methods must implement these functions
+FrequencyMeasurement& FrequencyMeasurement::getThis() { return *this; }
+
+void FrequencyMeasurement::_setup() {
+  funcResults.resize(numberOfPhysicalSites + 1);
+  label = Primary.getLabel();
+  pin(extractPinsFromGroup(_pin));
+}
+
+void FrequencyMeasurement::_execute() {
+  int site;
+
+  ON_FIRST_INVOCATION_BEGIN();
+
+  RDI_BEGIN();
+
+  if (_port.empty()) {
+    SMART_RDI::DIG_CAP& prdi =
+        rdi.digCap(suiteName).label(label).pin(_pin).bitPerWord(1).samples(
+            _samples);
+
+    filterRDI(prdi);
+    prdi.execute();
+
+  } else {
+    SMART_RDI::DIG_CAP& prdi = rdi.port(_port)
+                                   .digCap(suiteName)
+                                   .vecVarOnly()
+                                   .pin(_pin)
+                                   .bitPerWord(1)
+                                   .samples(_samples);
+
+    filterRDI(prdi);
+    prdi.execute();
+    rdi.port(_port).func().burst(label).execute();
+  }
+
+  RDI_END();
+
+  FOR_EACH_SITE_BEGIN();
+  site = CURRENT_SITE_NUMBER();
+  funcResults[site] = rdi.getBurstPassFail();
+  FOR_EACH_SITE_END();
+
+  ON_FIRST_INVOCATION_END();
+}
+
+void FrequencyMeasurement::serialProcessing(int site) {
+  if (_processResults) {
+    double result;
+    ARRAY_I captureData = rdi.site(site).id(suiteName).getVector();
+
+    if (_periodBased) {
+      result = calculatePeriod(captureData, _periodInNs);
+    } else {
+      result = calculateFrequency(captureData, _periodInNs);
+    }
+
+    judgeAndDatalog(testName() + "_FUNC",
+                    invertFunctionalResultIfRequired(funcResults[site]));
+
+    judgeAndDatalog(filterResult(result));
+  }
+}
+
+void FrequencyMeasurement::SMC_backgroundProcessing() {
+  double result;
+
+  for (int i = 0; i < activeSites.size(); i++) {
+    int site = activeSites[i];
+    process(site);
+    if (_processResults) {
+      ARRAY_I captureData = rdi.site(site).id(suiteName).getVector();
+      if (_periodBased) {
+        result = calculatePeriod(captureData, _periodInNs);
+      } else {
+        result = calculateFrequency(captureData, _periodInNs);
+      }
+      SMC_TEST(site, "", suiteName, LIMIT(TM::GE, 1, TM::LE, 1),
+               funcResults[site]);
+      SMC_TEST(site, _pin, suiteName, testLimits().TEST_API_LIMIT,
+               filterResult(result));
+    }
+  }
+}
+}
+}

data/src/advantest/smt7/origen/origen/test_method/frequency_measurement.hpp

@@ -0,0 +1,46 @@
+#ifndef ORIGEN_TEST_METHOD_FREQUENCY_MEASUREMENT_INCLUDED
+#define ORIGEN_TEST_METHOD_FREQUENCY_MEASUREMENT_INCLUDED
+
+#include "base.hpp"
+#include "mapi.hpp"
+#include "rdi.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+class FrequencyMeasurement : public Base {
+  void serialProcessing(int site);
+
+  int _periodBased;
+  string _pin;
+  string _port;
+  int _samples;
+  int _periodInNs;
+  int _processResults;
+
+ public:
+  FrequencyMeasurement();
+  virtual ~FrequencyMeasurement();
+  void SMC_backgroundProcessing();
+
+  FrequencyMeasurement& periodBased(int v);
+  FrequencyMeasurement& pin(string v);
+  FrequencyMeasurement& port(string v);
+  FrequencyMeasurement& samples(int v);
+  FrequencyMeasurement& periodInNs(int v);
+  FrequencyMeasurement& processResults(int v);
+
+ protected:
+  typedef FrequencyMeasurement super;
+  FrequencyMeasurement& getThis();
+  void _setup();
+  void _execute();
+
+  string label;
+  vector<int> funcResults;
+};
+}
+}
+#endif