origen_std_lib 0.7.0 → 0.8.0

data/stdlib/v93k/origen/origen/site.cpp

@@ -0,0 +1,220 @@
+#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));
+
+ 	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/stdlib/v93k/origen/origen/site.hpp

@@ -0,0 +1,51 @@
+#ifndef ORIGEN_SITE_HPP_
+#define ORIGEN_SITE_HPP_
+
+#include <string>
+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/stdlib/v93k/origen/origen/test_method.hpp

@@ -0,0 +1,17 @@
+#ifndef ORIGEN_TEST_METHOD_INCLUDED
+#define ORIGEN_TEST_METHOD_INCLUDED
+
+#include "mapi.hpp"
+#include "rdi.hpp"
+
+#define origen getThis()
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+}
+}
+
+#endif

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

@@ -0,0 +1,151 @@
+#ifndef ORIGEN_TEST_METHOD_BASE_INCLUDED
+#define ORIGEN_TEST_METHOD_BASE_INCLUDED
+
+#include "../test_method.hpp"
+#include "../../origen.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+class Base {
+    bool _async;
+    bool _syncup;
+
+public:
+    virtual ~Base() {
+    }
+    Base() {
+        async(false);
+        syncup(false);
+    }
+
+    Base & async(bool v) { _async = v; return *this; }
+    Base & syncup(bool v) { _syncup = v; return *this; }
+
+protected:
+    /// Returns 1 when running in offline mode
+    int offline() {
+    	int flag;
+        GET_SYSTEM_FLAG("offline", &flag);
+        return flag;
+    }
+
+    // Returns an object containing the test limits, this can be passed to SMT APIs that take a LIMITS
+    // object argument. To actually get the limit values use loLimit() and hiLimit().
+    LIMIT limits() {
+        return GET_LIMIT_OBJECT("Functional");
+    }
+
+    /// Returns the high limit value in whole units, i.e. A or V
+    double hiLimit() {
+        double lim = 0.0;
+        double * plim = &lim;
+
+        limits().getHigh(plim);
+        return lim;
+    }
+
+    /// Returns the low limit value in whole units, i.e. A or V
+    double loLimit() {
+        double lim = 0.0;
+        double * plim = &lim;
+
+        limits().getLow(plim);
+        return lim;
+    }
+
+    // Called immediately before the first RDI operation is executed
+    virtual void preTestFunc() {
+    }
+    virtual void preTestFunc(int site) {
+    }
+
+    // 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 holdStateFunc() {
+    }
+    virtual void holdStateFunc(int site) {
+    }
+
+    // Called after the last RDI operation has executed and all results have been
+    // fetched
+    virtual void postTestFunc() {
+    }
+    virtual void postTestFunc(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 processFunc(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 callPreTestFunc() {
+    	if (syncup()) {
+			synchronize();
+		}
+    	preTestFunc();
+    	FOR_EACH_SITE_BEGIN();
+    	preTestFunc(CURRENT_SITE_NUMBER());
+    	FOR_EACH_SITE_END();
+    }
+
+    void callHoldStateFunc() {
+    	holdStateFunc();
+    	FOR_EACH_SITE_BEGIN();
+    	holdStateFunc(CURRENT_SITE_NUMBER());
+    	FOR_EACH_SITE_END();
+    }
+
+    template <class T>
+    void callPostTestFunc(T* obj) {
+    	ON_FIRST_INVOCATION_BEGIN();
+    	postTestFunc();
+    	FOR_EACH_SITE_BEGIN();
+    	postTestFunc(CURRENT_SITE_NUMBER());
+    	FOR_EACH_SITE_END();
+    	ON_FIRST_INVOCATION_END();
+
+        if (async()) {
+        	SMC_ARM_internal(obj);
+        } else {
+        	processFunc(CURRENT_SITE_NUMBER());
+        	this->serialProcessing(CURRENT_SITE_NUMBER());
+		}
+    }
+};
+}
+}
+
+#endif /* BASE_HPP_ */

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

@@ -0,0 +1,182 @@
+#include "dc_measurement.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+
+// Defaults
+DCMeasurement::DCMeasurement() {
+    applyShutdown(1);
+    checkShutdown(1);
+    measure("VOLT");
+    settlingTime(0);
+    forceValue(0);
+    iRange(0);
+    processResults(1);
+    badc(0);
+}
+
+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::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::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);
+        funcResultsPre.resize(physicalSites + 1);
+        funcResultsPost.resize(physicalSites + 1);
+        GET_TESTSUITE_NAME(testSuiteName);
+        label = Primary.getLabel();
+
+        pin(extractPinsFromGroup(_pin));
+
+        if (_applyShutdown) {
+            if (_shutdownPattern.empty()) {
+                ostringstream pat;
+                pat << label << "_part1";
+                shutdownPattern(pat.str());
+            }
+        }
+
+        if (!_iRange && _measure == "CURR") {
+        	double l = loLimit();
+        	double h = hiLimit();
+        	if (l == 0 && h == 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(l) > abs(h))
+        		_iRange = abs(l);
+        	else
+        	    _iRange = abs(h);
+        }
+
+
+        callPreTestFunc();
+
+        RDI_BEGIN();
+
+        rdi.func(testSuiteName + "f1").label(label).execute();
+
+        callHoldStateFunc();
+
+		if(_measure == "VOLT") {
+
+			if (_badc) {
+          		    rdi.dc(testSuiteName)
+			       .pin(_pin, TA::BADC)
+			       .measWait(_settlingTime)
+			       .vMeas()
+			       .execute();
+
+			} else {
+			    SMART_RDI::dcBase & prdi = rdi.dc(testSuiteName)
+                                        .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.dc(testSuiteName)
+										  .pin(_pin)
+										  .vForce(_forceValue)
+										  .relay(TA::ppmuRly_onPPMU_offACDC,TA::ppmuRly_onAC_offDCPPMU)
+										  .measWait(_settlingTime)
+										  .iRange(_iRange)
+										  .iMeas();
+			filterRDI(prdi);
+			prdi.execute();
+		}
+
+		if (_applyShutdown) rdi.func(testSuiteName + "f2").label(_shutdownPattern).execute();
+
+        RDI_END();
+
+        FOR_EACH_SITE_BEGIN();
+            site = CURRENT_SITE_NUMBER();
+            funcResultsPre[site] = rdi.id(testSuiteName + "f1").getPassFail();
+            if (_applyShutdown) funcResultsPost[site] = rdi.id(testSuiteName + "f2").getPassFail();
+            // TODO: This retrieval needs to move to the SMC func in the async case
+            if (offline()) {
+            	if (!loLimit() && !hiLimit()) {
+            		results[site] = 0;
+            	} else if(loLimit() && hiLimit()) {
+            		results[site] = ((hiLimit() - loLimit()) / 2) + loLimit();
+            	} else if (loLimit()) {
+            		results[site] = loLimit();
+            	} else {
+            		results[site] = hiLimit();
+            	}
+
+            } else {
+            	results[site] = rdi.id(testSuiteName).getValue();
+            }
+
+        FOR_EACH_SITE_END();
+
+    ON_FIRST_INVOCATION_END();
+
+    callPostTestFunc(this);
+}
+
+void DCMeasurement::serialProcessing(int site) {
+	if (_processResults) {
+	    logFunctionalTest(testSuiteName, site, funcResultsPre[site] == 1, label);
+		TESTSET().cont(true).judgeAndLog_FunctionalTest(funcResultsPre[site] == 1);
+
+		logParametricTest(testSuiteName, site, filterResult(results[site]), limits(), _pin);
+		TESTSET().judgeAndLog_ParametricTest(_pin, testSuiteName, limits(), filterResult(results[site]));
+
+        if (_applyShutdown && _checkShutdown) {
+            logFunctionalTest(testSuiteName, site, funcResultsPost[site] == 1, _shutdownPattern);
+            TESTSET().cont(true).judgeAndLog_FunctionalTest(funcResultsPost[site] == 1);
+        }
+	}
+}
+
+void DCMeasurement::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), funcResultsPre[site]);
+			if (_applyShutdown && _checkShutdown) SMC_TEST(site, "", testSuiteName, LIMIT(TM::GE, 1, TM::LE, 1), funcResultsPost[site]);
+			SMC_TEST(site, _pin, testSuiteName, limits(), filterResult(results[site]));
+		}
+    }
+}
+
+}
+}