origen_std_lib 0.10.1 → 0.13.1

data/src/advantest/smt7/origen/origen/helpers/time.cpp

@@ -0,0 +1,64 @@
+/** @file */
+#include <stdlib.h>
+#include <cerrno>
+#include "../../origen.hpp"
+#include "../helpers.hpp"
+
+using namespace std;
+
+namespace Origen {
+
+namespace Time {
+
+static bool timeSet = false;
+static int _month;
+static int _day;
+static int _hour;
+static int _minute;
+static int _second;
+
+static time_t rawtime;
+static struct tm* timeinfo;
+
+void initTime(bool reset) {
+  if ((!timeSet) || reset) {
+    time(&rawtime);
+    timeinfo = localtime(&rawtime);
+    _month = (timeinfo->tm_mon + 1);
+    _day = timeinfo->tm_mday;
+    _hour = timeinfo->tm_hour;
+    _minute = timeinfo->tm_min;
+    _second = timeinfo->tm_sec;
+    timeSet = true;
+  }
+}
+
+/// Get the Month.
+int month() {
+  initTime();  // set the time if not already
+  return _month;
+}
+
+/// Get the Day.
+int day() {
+  initTime();  // set the time if not already
+  return _day;
+}
+/// Get the Hour.
+int hour() {
+  initTime();  // set the time if not already
+  return _hour;
+}
+/// Get the Minute.
+int minute() {
+  initTime();  // set the time if not already
+  return _minute;
+}
+/// Get the Second.
+int second() {
+  initTime();  // set the time if not already
+  return _second;
+}
+
+}  // end namespace Time
+}  // end namespace Origen

data/{stdlib/v93k → src/advantest/smt7}/origen/origen/helpers.hpp

@@ -1,28 +1,33 @@
 #ifndef ORIGEN_HELPERS_INCLUDED
 #define ORIGEN_HELPERS_INCLUDED
 
+#include <stdlib.h>
+#include <cerrno>
+#include <string>
+#include "../origen.hpp"
 #include "mapi.hpp"
 #include "rdi.hpp"
-#include <string>
 
 using namespace std;
 
 namespace Origen {
 
 string extractPinsFromGroup(const string&);
+bool pinExists(const string& pinName);
 void synchronize(double = 1);
 double calculateFrequency(const ARRAY_I&, double);
 double calculatePeriod(const ARRAY_I&, double);
+void overlaySubroutineOutput(string, string, uint64_t, int, int, int);
 void overlaySubroutine(string, string, uint64_t, int);
 void reverseOverlaySubroutine(string, string, uint64_t, int);
 int numberOfOnes(uint32_t);
 int numberOfZeros(uint32_t);
-int64_t toInt (string, int = 0);
-uint64_t toUInt (string, int = 0);
+int64_t toInt(string, int = 0);
+uint64_t toUInt(string, int = 0);
 vector<string> split(const string&, char);
 void split(const string&, char, vector<string>&);
-string toHex (const uint64_t&);
-string toStr (const uint64_t&);
+string toHex(const uint64_t&);
+string toStr(const uint64_t&);
 void initializeSites();
 void logParametricTest(string, int, double, LIMIT, string);
 void logFunctionalTest(string, int, bool, string);
@@ -30,16 +35,28 @@ bool isPass(double, LIMIT);
 string loStr(LIMIT);
 string hiStr(LIMIT);
 string upcase(string);
+string downcase(string);
 string lpad(string, int, char);
 string rpad(string, int, char);
 bool isEven(uint64_t);
 bool isOdd(uint64_t);
 LIMIT noLimits();
 uint64_t flip(uint64_t, int);
-string ltrim(string, const char * remove_chars = " \n\t\r\f\v");
-string rtrim(string, const char * remove_chars = " \n\t\r\f\v");
-string trim(string, const char * remove_chars = " \n\t\r\f\v");
+string ltrim(string, const char* remove_chars = " \n\t\r\f\v");
+string rtrim(string, const char* remove_chars = " \n\t\r\f\v");
+string trim(string, const char* remove_chars = " \n\t\r\f\v");
+double getUnitMultiplier(const string& units);
+string getLabelFromBurst(const string& burst, const string& port);
+string checksum16bits(const string&);
 
+namespace Time {
+void initTime(bool = false);
+int month();
+int day();
+int hour();
+int minute();
+int second();
+}
 }
 
 #endif

data/src/advantest/smt7/origen/origen/site.cpp

@@ -0,0 +1,237 @@
+#include "site.hpp"
+#include <libcicpi.h>
+#include <iostream>
+#include "helpers.hpp"
+using namespace std;
+
+namespace Origen {
+
+Site::Site(int number) {
+  _number = number;
+  lotidSet = false;
+  waferSet = false;
+  xSet = false;
+  ySet = false;
+  binSet = false;
+  softbinSet = false;
+}
+Site::~Site() {}
+
+/// Set the lot ID to the given value, e.g. "ABC1234"
+void Site::lotid(string val) {
+  lotidSet = true;
+  _lotid = val;
+}
+
+/// Set the lot ID based on the integer representation returned from lotidInt
+void Site::lotid(uint64_t val) {
+  string id = "";
+
+  for (int i = 0; i < 8; i++) {
+    int ch = val >> (8 * (7 - i));
+    if (ch != 0) {
+      id = id + (char)ch;
+    }
+  }
+
+  lotid(id);
+}
+
+/// Get the lot ID. If it has not previously been set to a value it will be
+/// automatically queried from the test system.
+string Site::lotid() {
+  if (!lotidSet) {
+    char value[CI_CPI_MAX_MODL_STRING_LEN * 2];
+    if (!GetModelfileString(const_cast<char*>("LOT_ID"), value)) {
+      _lotid = (string)value;
+    } else {
+      _lotid = "Undefined";
+    }
+    lotidSet = true;
+  }
+  return _lotid;
+}
+
+/// Returns the lot ID as a 64-bit integer that is suitable for programming to
+/// the device.
+/// Each character in the lotID is converted to its ASCII code.
+/// An error will be raised if the length of the current lotID overflows
+/// 64-bits.
+uint64_t Site::lotidInt() {
+  string id = lotid();
+  stringstream val;
+
+  // If the ID is > 8 chars then lose the upper chars, making the assuming that
+  // the lower ones are
+  // the more significant ones for the purposes of identifying a particular lot
+  if (id.length() > 8) {
+    id = id.substr(id.length() - 8, 8);
+  }
+  if (id.length() > 0) val << toHex((int)id.at(0));
+  if (id.length() > 1) val << toHex((int)id.at(1));
+  if (id.length() > 2) val << toHex((int)id.at(2));
+  if (id.length() > 3) val << toHex((int)id.at(3));
+  if (id.length() > 4) val << toHex((int)id.at(4));
+  if (id.length() > 5) val << toHex((int)id.at(5));
+  if (id.length() > 6) val << toHex((int)id.at(6));
+  if (id.length() > 7) val << toHex((int)id.at(7));
+
+  // if conversion was wrong for any reason setup val to a default value to
+  // ensure fail.
+  if (val.str().length() > 16) {
+    val.str("FFFFFFFFFFFFFFFE");
+  }
+
+  return toUInt(val.str(), 16);
+}
+
+/// Set the wafer number to the given value
+void Site::wafer(int val) {
+  waferSet = true;
+  if (val < 0 || val > 255) {
+    cout << "ERROR: Wafer is out of the range of a UInt8: " << val << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+  _wafer = (uint8_t)val;
+}
+
+/// Get the wafer number. If it has not previously been set to a value it will
+/// be automatically queried from the test system.
+int Site::wafer() {
+  if (!waferSet) {
+    char value[CI_CPI_MAX_MODL_STRING_LEN * 2];
+
+    //      if (!GetModelfileString(const_cast<char*>("WAFER_ID"), value)) {
+    // Expect to return something like "AB1234-15AA", where 15 is the wafer
+    // number
+    // wafer(toInt(split((string) value, '-')[1].substr(0, 2)));
+    if (!GetModelfileString(const_cast<char*>("WAFER_NUMBER"), value)) {
+      wafer(toInt((string)value));
+    } else {
+      wafer(0xFF);
+    }
+    waferSet = true;
+  }
+  return _wafer;
+}
+
+/// Set the X co-ordinate to the given value
+void Site::x(int val) {
+  xSet = true;
+  _x = val;
+}
+
+/// Get the X co-ord. If it has not previously been set to a value it will be
+/// automatically queried from the test system.
+int Site::x() {
+  if (!xSet) {
+    long lx, ly;
+    GetDiePosXYOfSite(_number, &lx, &ly);
+    if (lx < -32768 || lx > 32767) {
+      cout << "ERROR: X is out of the range of an Int16: " << lx << endl;
+      ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    if (ly < -32768 || ly > 32767) {
+      cout << "ERROR: Y is out of the range of an Int16: " << ly << endl;
+      ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    _x = (int)lx;
+    _y = (int)ly;
+    xSet = true;
+    ySet = true;
+  }
+  return _x;
+}
+
+/// Set the Y co-ordinate to the given value
+void Site::y(int val) {
+  ySet = true;
+  _y = val;
+}
+
+/// Get the Y co-ord. If it has not previously been set to a value it will be
+/// automatically queried from the test system.
+int Site::y() {
+  if (!ySet) {
+    long lx, ly;
+    GetDiePosXYOfSite(_number, &lx, &ly);
+    if (lx < -32768 || lx > 32767) {
+      cout << "ERROR: X is out of the range of an Int16: " << lx << endl;
+      ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    if (ly < -32768 || ly > 32767) {
+      cout << "ERROR: Y is out of the range of an Int16: " << ly << endl;
+      ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    _x = (int)lx;
+    _y = (int)ly;
+    xSet = true;
+    ySet = true;
+  }
+  return _y;
+}
+
+/// Set the site's bin to the given value, but only if a bin has not already
+/// been set.
+/// Note that this does not actually bin out the site but just records the bin
+/// assignment
+/// in a variable that can be retrieved by calling bin().
+void Site::bin(int val) {
+  if (!binSet) {
+    binSet = true;
+    _bin = val;
+  }
+}
+
+/// Set the site's bin to the given value, but only if a bin has not already
+/// been set or
+/// if the force argument is set to true, in which case it will overwrite any
+/// previous
+/// assignment.
+/// Note that this does not actually bin out the site but just records the bin
+/// assignment
+/// in a variable that can be retrieved by calling bin().
+void Site::bin(int val, bool force) {
+  if (!binSet || force) {
+    binSet = true;
+    _bin = val;
+  }
+}
+
+/// Returns the bin that has been assigned to the site by previously calling
+/// bin(int), if no
+/// bin has been assigned then it will return 0.
+int Site::bin() { return (binSet) ? _bin : 0; }
+
+/// Set the site's softbin to the given value, but only if a softbin has not
+/// already been set.
+/// Note that this does not actually bin out the site but just records the
+/// softbin assignment
+/// in a variable that can be retrieved by calling softbin().
+void Site::softbin(int val) {
+  if (!softbinSet) {
+    softbinSet = true;
+    _softbin = val;
+  }
+}
+
+/// Set the site's softbin to the given value, but only if a softbin a has not
+/// already been set or
+/// if the force argument is set to true, in which case it will overwrite any
+/// previous
+/// assignment.
+/// Note that this does not actually bin out the site but just records the
+/// softbin assignment
+/// in a variable that can be retrieved by calling softbin().
+void Site::softbin(int val, bool force) {
+  if (!softbinSet || force) {
+    softbinSet = true;
+    _softbin = val;
+  }
+}
+
+/// Returns the bin that has been assigned to the site by previously calling
+/// bin(int), if no
+/// bin has been assigned then it will return 0.
+int Site::softbin() { return (softbinSet) ? _softbin : 0; }
+} /* namespace Origen */

data/src/advantest/smt7/origen/origen/site.hpp

@@ -0,0 +1,50 @@
+#ifndef ORIGEN_SITE_HPP_
+#define ORIGEN_SITE_HPP_
+
+#include <string>
+#include <inttypes.h>
+using namespace std;
+
+namespace Origen {
+
+class Site {
+  string _lotid;
+  bool lotidSet;
+  int _wafer;
+  bool waferSet;
+  int _x;
+  bool xSet;
+  int _y;
+  bool ySet;
+  int _number;
+  int _bin;
+  int _softbin;
+  bool binSet;
+  bool softbinSet;
+
+ public:
+  Site(int);
+  virtual ~Site();
+  string lotid();
+  uint64_t lotidInt();
+  void lotid(string);
+  void lotid(uint64_t);
+  int wafer();
+  void wafer(int);
+  int x();
+  void x(int);
+  int y();
+  void y(int);
+  int bin();
+  void bin(int);
+  void bin(int, bool);
+  int softbin();
+  void softbin(int);
+  void softbin(int, bool);
+
+  /// Returns the site number associated with the given site object
+  int number() { return _number; }
+};
+
+} /* namespace Origen */
+#endif

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

@@ -0,0 +1,231 @@
+#include "base.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+Base::Base() {
+  async(false);
+  syncup(false);
+}
+
+Base::~Base() {}
+
+/// Returns 1 when running in offline mode
+int Base::offline() {
+  int flag;
+  GET_SYSTEM_FLAG("offline", &flag);
+  return flag;
+}
+
+void Base::initialize() {
+  addParameter("testName", "string", &_testName,
+               testmethod::TM_PARAMETER_INPUT);
+  addParameter("forcePass", "int", &_forcePass, testmethod::TM_PARAMETER_INPUT);
+  addParameter("onPassFlag", "string", &_onPassFlag,
+               testmethod::TM_PARAMETER_INPUT);
+  addParameter("onFailFlag", "string", &_onFailFlag,
+               testmethod::TM_PARAMETER_INPUT);
+
+  bFirstRun = true;
+
+  init();
+}
+
+void Base::run() {
+  ARRAY_I sites;
+
+  RDI_INIT();
+
+  ON_FIRST_INVOCATION_BEGIN();
+
+  enableHiddenUpload();
+
+  GET_ACTIVE_SITES(activeSites);
+  numberOfPhysicalSites = GET_CONFIGURED_SITES(sites);
+  GET_TESTSUITE_NAME(suiteName);
+  suiteFailed.resize(numberOfPhysicalSites + 1);
+
+  _setup();
+
+  callPreBody();
+
+  ON_FIRST_INVOCATION_END();
+
+  suiteFailed[CURRENT_SITE_NUMBER()] = 0;
+
+  body();
+
+  callPostBody(this);
+
+  if (suiteFailed[CURRENT_SITE_NUMBER()]) {
+    if (_onFailFlag != "") {
+      SET_USER_DOUBLE(_onFailFlag, 1);
+    }
+  } else {
+    if (_onPassFlag != "") {
+      SET_USER_DOUBLE(_onPassFlag, 1);
+    }
+  }
+
+  bFirstRun = false;
+}
+
+void Base::datalog(double value) {
+  TESTSET()
+      .testnumber(testNumber())
+      .cont(true)
+      .TEST("", testName(), noLimits(), value);
+}
+
+void Base::datalog(string testName, double value) {
+  TESTSET()
+      .testnumber(testNumber(testName))
+      .cont(true)
+      .TEST("", testName, noLimits(), value);
+}
+
+void Base::judgeAndDatalog(double value) {
+  bool alreadyFailed = suiteFailed[CURRENT_SITE_NUMBER()];
+
+  if (!alreadyFailed) {
+    suiteFailed[CURRENT_SITE_NUMBER()] = !preJudge(value);
+  }
+
+  TESTSET()
+      .testnumber(testNumber())
+      .cont(true)
+      .judgeAndLog_ParametricTest(
+          "", testName(), _forcePass ? toNALimit(testLimits().TEST_API_LIMIT)
+                                     : testLimits().TEST_API_LIMIT,
+          value);
+
+  // Preserve the first bin assigned within this test suite as the final one
+  if ((!alreadyFailed) && (!_forcePass) &&
+      (suiteFailed[CURRENT_SITE_NUMBER()])) {
+    SET_MULTIBIN(testLimits().BinsNumString, testLimits().BinhNum);
+  }
+}
+
+void Base::judgeAndDatalog(string testName, double value) {
+  bool alreadyFailed = suiteFailed[CURRENT_SITE_NUMBER()];
+
+  if (!alreadyFailed) {
+    suiteFailed[CURRENT_SITE_NUMBER()] = !preJudge(testName, value);
+  }
+
+  TESTSET()
+      .testnumber(testNumber(testName))
+      .cont(true)
+      .judgeAndLog_ParametricTest(
+          "", testName,
+          _forcePass ? toNALimit(testLimits(testName).TEST_API_LIMIT)
+                     : testLimits(testName).TEST_API_LIMIT,
+          value);
+
+  // Preserve the first bin assigned within this test suite as the final one
+  if ((!alreadyFailed) && (!_forcePass) &&
+      (suiteFailed[CURRENT_SITE_NUMBER()])) {
+    SET_MULTIBIN(testLimits().BinsNumString, testLimits().BinhNum);
+  }
+}
+
+/// Returns true if the given value will pass the current test, but does not
+/// affect the site status if it fails
+bool Base::preJudge(double value) {
+  return isWithinLimits(value, testLimits().TEST_API_LIMIT);
+}
+
+/// Returns true if the given value will pass the given test, but does not
+/// affect the site status if it fails
+bool Base::preJudge(string testName, double value) {
+  return isWithinLimits(value, testLimits(testName).TEST_API_LIMIT);
+}
+
+/// Returns true if the given value is within the given limits
+bool Base::isWithinLimits(double value, LIMIT limits) {
+  bool passed = true;
+  double dHigh(0), dLow(0);
+  TM::COMPARE cHigh, cLow;
+
+  limits.get(cLow, dLow, cHigh, dHigh);
+
+  if (cLow == TM::GT && value <= dLow) {
+    passed = false;
+  } else if (cLow == TM::GE && value < dLow) {
+    passed = false;
+  }
+
+  if (cHigh == TM::LT && value >= dHigh) {
+    passed = false;
+  } else if (cHigh == TM::LE && value > dHigh) {
+    passed = false;
+  }
+  return passed;
+}
+
+/// Converts the given limits object to an equivalent version with the limit
+/// types set to N/A
+LIMIT Base::toNALimit(LIMIT limits) {
+  LIMIT naLimit(limits);
+  double dHigh(0), dLow(0);
+  limits.getHigh(&dHigh);
+  limits.getLow(&dLow);
+  naLimit.high(TM::NA, dHigh);
+  naLimit.low(TM::NA, dLow);
+  return naLimit;
+}
+
+/// Returns the base test number
+int Base::testNumber() { return testLimits().TestNumber; }
+
+/// Returns the test test number for the given test name
+int Base::testNumber(string testName) {
+  return testLimits(testName).TestNumber;
+}
+
+/// Returns the base test limits
+TMLimits::LimitInfo Base::testLimits() {
+  // Doesn't seem like this should be required from the documentation, but had
+  // some
+  // problems with getLimitRef not working properly without it when other code
+  // has set
+  // a specific key.
+  tmLimits.setDefaultLookupKeys();
+  return tmLimits.getLimitRef(suiteName, testName());
+}
+
+/// Returns the test limits for the given test name
+TMLimits::LimitInfo Base::testLimits(string testName) {
+  // Doesn't seem like this should be required from the documentation, but had
+  // some
+  // problems with getLimitRef not working properly without it when other code
+  // has set
+  // a specific key.
+  tmLimits.setDefaultLookupKeys();
+  return tmLimits.getLimitRef(suiteName, testName);
+}
+
+/// Returns the value of the testName parameter supplied from the test suite, or
+/// if not supplied falls back
+/// to the test suite name
+string Base::testName() {
+  if (_testName == "") {
+    return suiteName;
+  } else {
+    return _testName;
+  }
+}
+
+/// Changes a 0 -> 1 and 1 -> 0 if Origen::invertFunctionalResults has been set
+/// to true
+int Base::invertFunctionalResultIfRequired(int v) {
+  if (Origen::invertFunctionalResults) {
+    return v == 1 ? 0 : 1;
+  } else {
+    return v;
+  }
+}
+}
+}