origen_std_lib 0.7.0 → 0.8.0

data/stdlib/v93k/origen/origen/test_method/dc_measurement.hpp

@@ -0,0 +1,59 @@
+#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;
+    double _forceValue;
+    double _iRange;
+    int _processResults;
+    int _badc;
+
+public:
+    DCMeasurement();
+    virtual ~DCMeasurement();
+    void SMC_backgroundProcessing();
+    void execute();
+
+    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 & forceValue(double v);
+    DCMeasurement & iRange(double v);
+    DCMeasurement & processResults(int v);
+    DCMeasurement & badc(int v);
+
+protected:
+     DCMeasurement & getThis();
+
+    // Member/instance variables, declared outside the execute function body since
+    // they may be useful to refer to in callback functions
+    ARRAY_I activeSites;
+    string testSuiteName;
+    string label;
+    vector<int> funcResultsPre;
+    vector<int> funcResultsPost;
+    vector<double> results;
+};
+
+}
+}
+#endif

data/stdlib/v93k/origen/origen/test_method/frequency_measurement.cpp

@@ -0,0 +1,109 @@
+#include "frequency_measurement.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+
+FrequencyMeasurement::FrequencyMeasurement() {
+    samples(2000);
+    processResults(1);
+}
+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; }
+/// 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::execute() {
+
+    int site, physicalSites;
+    ARRAY_I sites;
+
+    RDI_INIT();
+
+    ON_FIRST_INVOCATION_BEGIN();
+
+    enableHiddenUpload();
+    GET_ACTIVE_SITES(activeSites);
+    physicalSites = GET_CONFIGURED_SITES(sites);
+    funcResults.resize(physicalSites + 1);
+    GET_TESTSUITE_NAME(testSuiteName);
+    label = Primary.getLabel();
+    pin(extractPinsFromGroup(_pin));
+
+    callPreTestFunc();
+
+    RDI_BEGIN();
+
+    SMART_RDI::DIG_CAP & prdi = rdi.digCap(testSuiteName)
+								   .label(label)
+								   .pin(_pin)
+								   .bitPerWord(1)
+								   .samples(_samples);
+
+	filterRDI(prdi);
+	prdi.execute();
+
+    RDI_END();
+
+    FOR_EACH_SITE_BEGIN();
+        site = CURRENT_SITE_NUMBER();
+        funcResults[site] = rdi.getBurstPassFail();
+    FOR_EACH_SITE_END();
+
+    ON_FIRST_INVOCATION_END();
+
+    callPostTestFunc(this);
+}
+
+void FrequencyMeasurement::serialProcessing(int site) {
+	if (_processResults) {
+		double result;
+		ARRAY_I captureData = rdi.site(site).id(testSuiteName).getVector();
+
+		if (_periodBased) {
+			result = calculatePeriod(captureData, _periodInNs);
+		} else {
+			result = calculateFrequency(captureData, _periodInNs);
+		}
+		logFunctionalTest(testSuiteName, site, funcResults[site] == 1, label);
+		TESTSET().judgeAndLog_FunctionalTest(funcResults[site] == 1);
+
+		logParametricTest(testSuiteName, site, filterResult(result), limits(), _pin);
+		TESTSET().judgeAndLog_ParametricTest(_pin, testSuiteName, limits(), filterResult(result));
+	}
+}
+
+void FrequencyMeasurement::SMC_backgroundProcessing() {
+    double result;
+
+	for (int i = 0; i < activeSites.size(); i++) {
+		int site = activeSites[i];
+		processFunc(site);
+		if (_processResults) {
+			ARRAY_I captureData = rdi.site(site).id(testSuiteName).getVector();
+			if (_periodBased) {
+				result = calculatePeriod(captureData, _periodInNs);
+			} else {
+				result = calculateFrequency(captureData, _periodInNs);
+			}
+			SMC_TEST(site, "", testSuiteName, LIMIT(TM::GE, 1, TM::LE, 1), funcResults[site]);
+			SMC_TEST(site, _pin, testSuiteName, limits(), filterResult(result));
+		}
+	}
+}
+
+}
+}

data/stdlib/v93k/origen/origen/test_method/frequency_measurement.hpp

@@ -0,0 +1,48 @@
+#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;
+    int _samples;
+    int _periodInNs;
+    int _processResults;
+
+public:
+    FrequencyMeasurement();
+    virtual ~FrequencyMeasurement();
+    void SMC_backgroundProcessing();
+    void execute();
+
+    FrequencyMeasurement & periodBased(int v);
+    FrequencyMeasurement & pin(string v);
+    FrequencyMeasurement & samples(int v);
+    FrequencyMeasurement & periodInNs(int v);
+    FrequencyMeasurement & processResults(int v);
+
+protected:
+    FrequencyMeasurement & getThis();
+
+    // Internal variables, declared outside the the execute function body since
+    // they may be useful in callback functions
+    ARRAY_I activeSites;
+    string testSuiteName;
+    string label;
+    vector<int> funcResults;
+
+};
+
+}
+}
+#endif

data/stdlib/v93k/origen/origen/test_method/functional_test.cpp

@@ -0,0 +1,119 @@
+#include "functional_test.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+
+FunctionalTest::FunctionalTest() {
+    pin("");
+    capture(0);
+    processResults(1);
+    bitPerWord(1);
+}
+
+FunctionalTest::~FunctionalTest() { }
+
+/// The functional test method can optionally capture data by supplying the number of vectors to capture
+FunctionalTest & FunctionalTest::capture(int v) { _capture = v; return *this; }
+/// If data capture is requested, supply the pin to capture data from
+FunctionalTest & FunctionalTest::pin(string v) { _pin = v; return *this; }
+/// Serial capture data will be grouped into words, specify how many bits per word in the serial stream (default 1)
+FunctionalTest & FunctionalTest::bitPerWord(int v) { _bitPerWord = v; return *this; }
+/// When set to 0 the results of the test will not be judged or logged
+FunctionalTest & FunctionalTest::processResults(int v) { _processResults = v; return *this; }
+
+// All test methods must implement this function
+FunctionalTest & FunctionalTest::getThis() { return *this; }
+
+void FunctionalTest::execute() {
+
+    int site, physicalSites;
+    ARRAY_I sites;
+
+    RDI_INIT();
+    ON_FIRST_INVOCATION_BEGIN();
+
+    enableHiddenUpload();
+    GET_ACTIVE_SITES(activeSites);
+    physicalSites = GET_CONFIGURED_SITES(sites);
+    results.resize(physicalSites + 1);
+    GET_TESTSUITE_NAME(testSuiteName);
+//    testSuiteName = testSuiteName + toStr(CURRENT_SITE_NUMBER());
+//    cout << testSuiteName << endl;
+    label = Primary.getLabel();
+
+    if (_capture) {
+        pinName = extractPinsFromGroup(_pin);
+    }
+
+    callPreTestFunc();
+
+    RDI_BEGIN();
+
+        if (_capture) {
+            SMART_RDI::DIG_CAP & prdi = rdi.digCap(testSuiteName)
+                                           .label(label)
+                                           .pin(pinName)
+                                           .bitPerWord(_bitPerWord)
+                                           .samples(_capture);
+            filterRDI(prdi);
+            prdi.execute();
+
+        } else {
+            SMART_RDI::FUNC & prdi = rdi.func(testSuiteName).label(label);
+//            SMART_RDI::FUNC & prdi = rdi.func(testSuiteName).burst(label);
+            filterRDI(prdi);
+            prdi.execute();
+        }
+
+    RDI_END();
+
+    FOR_EACH_SITE_BEGIN();
+        site = CURRENT_SITE_NUMBER();
+        if (_capture) {
+            results[site] = rdi.site(site).getBurstPassFail();
+//        	cout << "PRE " << site << ": " << results[site] << endl;
+
+        } else {
+            results[site] = rdi.site(site).id(testSuiteName).getPassFail();
+//            cout << "PRE " << site << ": " << results[site] << endl;
+        }
+    FOR_EACH_SITE_END();
+
+    ON_FIRST_INVOCATION_END();
+
+    callPostTestFunc(this);
+}
+
+/// Returns the captured data for the site currently in focus
+ARRAY_I FunctionalTest::capturedData() {
+    return rdi.id(testSuiteName).getVector(pinName);
+}
+
+/// Returns the captured data for the given site number
+ARRAY_I FunctionalTest::capturedData(int site) {
+    return rdi.site(site).id(testSuiteName).getVector(pinName);
+}
+
+void FunctionalTest::serialProcessing(int site) {
+	if (_processResults) {
+//		cout << "POST " << site << ": " << results[site] << endl;
+	    logFunctionalTest(testSuiteName, site, results[site] == 1, label);
+	    TESTSET().judgeAndLog_FunctionalTest(results[site] == 1);
+	}
+}
+
+void FunctionalTest::SMC_backgroundProcessing() {
+	for (int i = 0; i < activeSites.size(); i++) {
+		int site = activeSites[i];
+		processFunc(site);
+		if (_processResults) {
+			SMC_TEST(site, "", testSuiteName, LIMIT(TM::GE, 1, TM::LE, 1), results[activeSites[i]]);
+		}
+	}
+}
+
+}
+}

data/stdlib/v93k/origen/origen/test_method/functional_test.hpp

@@ -0,0 +1,51 @@
+#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 FunctionalTest: public Base  {
+    void serialProcessing(int site);
+
+    string _pin;
+    int _capture;
+    int _bitPerWord;
+    int _processResults;
+
+public:
+    FunctionalTest();
+
+    virtual ~FunctionalTest();
+    void SMC_backgroundProcessing();
+    void execute();
+
+    FunctionalTest & capture(int v);
+    FunctionalTest & pin(string v);
+    FunctionalTest & bitPerWord(int v);
+    FunctionalTest & processResults(int v);
+
+
+protected:
+    FunctionalTest & getThis();
+    ARRAY_I capturedData();
+    ARRAY_I capturedData(int);
+
+    // Internal variables, declared outside the the execute function body since
+    // they may be useful in callback functions
+    ARRAY_I activeSites;
+    string testSuiteName;
+    string label;
+    vector<int> results;
+    string pinName;
+};
+
+
+}
+}
+#endif

data/stdlib/v93k/origen/origen/utils.hpp

@@ -0,0 +1,12 @@
+#ifndef ORIGEN_UTILS_INCLUDED
+#define ORIGEN_UTILS_INCLUDED
+
+#include "utils/version.hpp"
+
+namespace Origen {
+namespace Utils {
+
+}
+}
+
+#endif

data/stdlib/v93k/origen/origen/utils/version.cpp

@@ -0,0 +1,79 @@
+#include "version.hpp"
+using namespace std;
+
+#include <sstream>
+
+namespace Origen {
+namespace Utils {
+
+Version::Version(string ver) {
+    vector<int> v = parse(ver);
+    _major = v[0];
+    _minor = v[1];
+    _tiny = v[2];
+}
+
+int Version::major() {
+    return _major;
+}
+int Version::minor() {
+    return _minor;
+}
+int Version::tiny() {
+    return _tiny;
+}
+
+string Version::str() {
+    ostringstream str;
+    str << _major;
+    str << ".";
+    str << _minor;
+    str << ".";
+    str << _tiny;
+    return str.str();
+}
+
+bool Version::operator==(string rhs) {
+    vector<int> v = parse(rhs);
+    return _major == v[0] && _minor == v[1] && _tiny == v[2];
+}
+
+bool Version::operator!=(string rhs) {
+    vector<int> v = parse(rhs);
+    return _major != v[0] || _minor != v[1] || _tiny != v[2];
+}
+
+bool Version::operator<(string rhs) {
+    vector<int> v = parse(rhs);
+    return _major < v[0] || (_major == v[0] && _minor < v[1])
+           || (_major == v[0] && _minor == v[1] && _tiny < v[2]);
+}
+
+bool Version::operator<=(string rhs) {
+    return operator==(rhs) || operator<(rhs);
+}
+
+bool Version::operator>(string rhs) {
+    vector<int> v = parse(rhs);
+    return _major > v[0] || (_major == v[0] && _minor > v[1])
+           || (_major == v[0] && _minor == v[1] && _tiny > v[2]);
+}
+
+bool Version::operator>=(string rhs) {
+    return operator==(rhs) || operator>(rhs);
+}
+
+vector<int> Version::parse(string ver) {
+    vector<int> v(3);
+
+    istringstream parser(ver);
+    parser >> v[0];
+    for (int i = 1; i < 3; i++) {
+        parser.get(); //Skip dot
+        parser >> v[i];
+    }
+    return v;
+}
+
+}
+}