origen_std_lib 0.9.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 90e033ed9a86e3be90b87659b9c9e5dc7f861240
-  data.tar.gz: b24eb49d30dba303bf7660150872b8a7a82269ff
+SHA256:
+  metadata.gz: 14b8444afc790a16b209561fafbdf315859448bdaa3b56672fa49bf9a3d626f6
+  data.tar.gz: 33df693bbc10b1d9b37fb8da1afb27947f029a46fc65ac74e88652cb9bcf53b6
 SHA512:
-  metadata.gz: ebca35973aa2876aa8d8d9586958ea342d305e2c963aa0948afb62dfaf64160937b514e01bca3bf1716705ceb953af207bff30935337b4a8cde3ed46ef89e05e
-  data.tar.gz: 4f134a1d9a9013d8217b93bae014dd4f42e34b9729b9c6ca6f7493f54db7246d56b54e4c4729f9bfe91ed7efbbac7d0b577acb7cd6075de4e0fd17c459f5ca60
+  metadata.gz: a8673d212602dcc57418e3d59da651cd76feeb430dc279bff640be8bb13de98782271bea9f0cffc451c1077d63e96c988dcebf60cd4629a83de81cfab750710b
+  data.tar.gz: dc9b3b4278b940f2e683c00f95835b143dbc812ab146c1d0f858fc4a229425094bd9d959c0b4e206cea6a493524f821a5350930cdc8503de41daaf169caaba65

data/config/application.rb

@@ -38,29 +38,18 @@ class OrigenStdLibApplication < Origen::Application
 
   config.semantically_version = true
 
-  # Copy the std lib into the app area for inclusion in the gem package
   def before_release_gem
-    d = "#{Origen.root}/stdlib/v93k"
-    FileUtils.rm_rf(d)  if File.exist?(d)
-    FileUtils.mkdir_p(d)
     # Remove all untracked files, e.g. compiled binaries
-    system "git clean -f -d -x #{Origen.root}/../v93k"
-    system "git clean -f -d #{Origen.root}/../v93k"
-    FileUtils.cp_r("#{Origen.root}/../v93k/src/origen", d)
-  end
-
-  # Get rid of the local std lib copy after building
-  def after_release_gem
-    FileUtils.rm_rf "#{Origen.root}/stdlib"
+    system "git clean -f -d -x #{Origen.root}/src"
+    system "git clean -f -d #{Origen.root}/src"
   end
 
   def after_web_site_compile(options={})
     if options[:api]
-      Dir.chdir "#{Origen.app.rc.root}/v93k" do
-        system "doxygen .doxygen"
-        d = "#{Origen.root}/web/output"
-        FileUtils.mkdir_p(d)
-        FileUtils.mv "html", "#{d}/v93k"
+      f = Origen.root.join "web", "output", "v93k_smt7"
+      FileUtils.mkdir_p(f)
+      Dir.chdir Origen.root.join "src", "advantest", "smt7", "origen" do
+        system "doxygen #{Origen.root.join('config', 'doxygen', 'v93k_smt7')}"
       end
     end
   end
@@ -92,7 +81,7 @@ class OrigenStdLibApplication < Origen::Application
   def before_release_tag(identifier, note, type, selector, options)
     v = Origen::VersionString.new(identifier)
     # Update the version in the C code
-    f = "#{Origen.app.rc.root}/v93k/src/origen/origen.hpp"
+    f = File.join(Origen.root, "src", "advantest", "smt7", "origen", "origen.hpp")
     data = File.read(f) 
     filtered_data = data.sub(/#define ORIGEN_VERSION \"\d+\.\d+\.\d+\"/, "#define ORIGEN_VERSION \"#{v}\"") 
     File.open(f, "w") do |f|
@@ -138,5 +127,4 @@ class OrigenStdLibApplication < Origen::Application
   #config.pattern_name_translator do |name|
   #  name.gsub(/_b\d/, "_bx")
   #end
-
 end

data/config/commands.rb

@@ -13,6 +13,14 @@ aliases ={
 # Now branch to the specific task code
 case @command
 
+when "format"
+  Dir.glob("#{Origen.root}/src/**/*.{cpp,hpp}").each do |f|
+    system "clang-format -i #{f}"
+  end
+  java_files = Dir.glob("#{Origen.root}/src/**/*.java")
+  system "java -jar vendor/google-java-format-1.7-all-deps.jar --replace #{java_files.join(' ')}"
+  exit 0
+
 ## Example of how to make a command to run unit tests, this simply invokes RSpec on
 ## the spec directory
 #when "specs"
@@ -55,6 +63,7 @@ else
   # before handing control back to Origen. Un-comment the example below to get started.
   @application_commands = <<-EOT
  examples     Run the examples (tests), -c will enable coverage
+ format       Format/prettify the library source files (requires clang-format and java to be available)
   EOT
 
 end 

data/config/version.rb

@@ -1,8 +1,7 @@
 module OrigenStdLib
   MAJOR = 0
-  MINOR = 9
+  MINOR = 13
   BUGFIX = 0
   DEV = nil
-
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
 end

data/lib/origen_std_lib/v93k.rb

@@ -4,6 +4,11 @@ module OrigenStdLib
               class_name:            'origen',
 
               functional_test:       {
+                port:         [:string, ''],
+                test_name:    [:string, ''],
+                force_pass:   [:boolean, false],
+                on_pass_flag: [:string, ''],
+                on_fail_flag: [:string, '']
               },
 
               dc_measurement:        {
@@ -15,9 +20,15 @@ module OrigenStdLib
                 measure:          [:string, 'VOLT', %w(VOLT CURR v i voltage current)],
                 settling_time:    [:double, 0],
                 pin:              [:string, nil],
+                port:             [:string, ''],
                 force_value:      [:double, 0],
                 i_range:          [:integer, nil],
                 badc:             [:integer, 0],
+                test_name:        [:string, ''],
+                force_pass:       [:boolean, false],
+                on_pass_flag:     [:string, ''],
+                on_fail_flag:     [:string, ''],
+
                 methods:          {
                   finalize: lambda  do |tm|
                     # Clean up the measurement type parameter
@@ -40,8 +51,13 @@ module OrigenStdLib
               frequency_measurement: {
                 period_based: [:integer, 0],
                 pin:          [:string, nil],
+                port:         [:string, ''],
                 samples:      [:integer, 2000],
-                period_in_ns: [:integer, nil]
+                period_in_ns: [:integer, nil],
+                test_name:    [:string, ''],
+                force_pass:   [:boolean, false],
+                on_pass_flag: [:string, ''],
+                on_fail_flag: [:string, '']
               },
 
               record_bin:            {

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

@@ -0,0 +1,18 @@
+/** @file */
+#include "origen.hpp"
+
+namespace Origen {
+
+Utils::Version version() {
+  Utils::Version v(ORIGEN_VERSION);
+  return v;
+}
+
+vector<Site> Sites;
+
+Site& site() { return Sites[CURRENT_SITE_NUMBER()]; }
+
+Site& site(int site) { return Sites[site]; }
+
+bool invertFunctionalResults = false;
+}

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

@@ -1,15 +1,15 @@
 #ifndef ORIGEN_HPP_INCLUDED
 #define ORIGEN_HPP_INCLUDED
 
-#define ORIGEN_VERSION "0.9.0"
+#define ORIGEN_VERSION "0.13.0"
 
 #ifndef debugger
 #define debugger __asm__("int $3");
 #endif
 
-#include "origen/utils.hpp"
 #include "origen/helpers.hpp"
 #include "origen/site.hpp"
+#include "origen/utils.hpp"
 
 namespace Origen {
 
@@ -17,6 +17,6 @@ extern vector Sites;
 Utils::Version version();
 Site& site();
 Site& site(int site);
-
+extern bool invertFunctionalResults;
 }
 #endif

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/helpers/console.cpp

@@ -0,0 +1,94 @@
+/** @file */
+#include "../helpers.hpp"
+
+namespace Origen {
+
+/// Prints the result of a parametric test to the console
+void logParametricTest(string name, int site, double result, LIMIT limits,
+                       string pin) {
+  cout << site << " ";
+  if (isPass(result, limits))
+    cout << "     ";
+  else
+    cout << "FAIL ";
+  cout << left << setw(65) << setfill(' ') << name << "  ";
+  cout << left << setw(20) << setfill(' ') << loStr(limits) << "  ";
+  cout << left << setw(20) << setfill(' ') << result;
+  cout << left << setw(20) << setfill(' ') << hiStr(limits);
+  cout << pin << endl;
+}
+
+/// Returns a LIMIT object with no limits enabled
+LIMIT noLimits() { return LIMIT(TM::NA, 0, TM::NA, 0); }
+
+/// Prints the result of a functional test to the console
+void logFunctionalTest(string name, int site, bool passed, string pattern) {
+  cout << site << " ";
+  if (passed)
+    cout << "     ";
+  else
+    cout << "FAIL ";
+  cout << left << setw(65) << setfill(' ') << name << "  ";
+  cout << pattern << endl;
+}
+
+/// Converts the low limit in the given LIMIT object into a string, where an
+/// empty string will be returned if the limit is not enabled
+string loStr(LIMIT limits) {
+  double lo = 0.0;
+  double* plo = &lo;
+  TM::COMPARE clo;
+
+  clo = limits.getLow(plo);
+
+  if (clo == TM::NA) {
+    return "";
+  } else {
+    stringstream val;
+    val << lo;
+    return val.str();
+  }
+}
+
+/// Converts the high limit in the given LIMIT object into a string, where an
+/// empty string will be returned if the limit is not enabled
+string hiStr(LIMIT limits) {
+  double hi = 0.0;
+  double* phi = &hi;
+  TM::COMPARE chi;
+
+  chi = limits.getHigh(phi);
+
+  if (chi == TM::NA) {
+    return "";
+  } else {
+    stringstream val;
+    val << hi;
+    return val.str();
+  }
+}
+/// Returns true if the result is within the given limits
+bool isPass(double val, LIMIT limits) {
+  double lo = 0.0;
+  double hi = 0.0;
+  double* plo = &lo;
+  double* phi = &hi;
+  TM::COMPARE clo, chi;
+  bool result;
+
+  clo = limits.getLow(plo);
+  chi = limits.getHigh(phi);
+
+  result = true;
+
+  if (clo != TM::NA) {
+    if (clo == TM::GE && val < lo) result = false;
+    if (clo == TM::GT && val <= lo) result = false;
+  }
+  if (chi != TM::NA) {
+    if (chi == TM::LE && val > hi) result = false;
+    if (chi == TM::LT && val >= hi) result = false;
+  }
+  return result;
+}
+}

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

@@ -0,0 +1,456 @@
+/** @file */
+#include "../helpers.hpp"
+
+using namespace std;
+
+namespace Origen {
+
+uint64_t flip(uint64_t input, int size) {
+  uint64_t output = 0;
+  for (int i = 0; i < size; i++) {
+    output <<= 1;
+    output |= input & 1;
+    input >>= 1;
+  }
+  return output;
+}
+
+/// Split the given string by the given delimiter and return the results in a
+/// vector of strings
+///
+///   split("AB1234-24", '-')   // => ["AB1234", "24"]
+vector<string> split(const string &str, char delim) {
+  vector<string> elems;
+  split(str, delim, elems);
+  return elems;
+}
+
+/// This version places the result in the supplied vector rather than returning
+/// a new one
+void split(const string &str, char delim, vector<string> &elems) {
+  stringstream ss;
+  ss.str(str);
+  string item;
+  while (getline(ss, item, delim)) {
+    elems.push_back(item);
+  }
+}
+
+///
+string ltrim(string str, const char *remove_chars /* = " \n\t\r\f\v" */) {
+  str.erase(0, str.find_first_not_of(remove_chars));
+  return str;
+}
+
+string rtrim(string str, const char *remove_chars /* = " \n\t\r\f\v" */) {
+  str.erase(str.find_last_not_of(remove_chars) + 1);
+  return str;
+}
+
+string trim(string str, const char *remove_chars /* = " \n\t\r\f\v" */) {
+  str = rtrim(str, remove_chars);
+  str = ltrim(str, remove_chars);
+  return str;
+}
+
+/// Convert the given string to a 64-bit integer. Works for both decimal and hex
+/// strings as
+/// shown in the examples below.
+///
+/// If the string is not successfully converted the site in focus will be binned
+/// out.
+///
+///   toInt("0xFF")         // => 255
+///   toInt("FF", 16)       // => 255 (must declare base 16 if no leading 0x)
+///   toInt("255")          // => 255
+int64_t toInt(string str, int base) {
+  str = trim(str);        // Remove any whitespace
+  str = ltrim(str, "0");  // Remove any leading 0's
+  if (str == "") {
+    return 0;
+  }
+  char *end;
+  char *cstr = const_cast<char *>(str.c_str());
+  long long int l;
+  errno = 0;
+  l = strtoll(cstr, &end, base);
+  if ((errno == ERANGE && l == LLONG_MAX) || l > LLONG_MAX) {
+    cout << "ERROR: String conversion overflowed a 64-bit integer - " << str
+         << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+  if ((errno == ERANGE && l == LLONG_MIN) || l < LLONG_MIN) {
+    cout << "ERROR: String conversion underflowed a 64-bit integer - " << str
+         << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+  if (*cstr == '\0' || *end != '\0') {
+    cout << "ERROR: String is not convertible to a 64-bit integer - " << str
+         << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+  return (int64_t)l;
+}
+
+/// See toInt, but returns an unsigned 64-bit integer
+uint64_t toUInt(string str, int base) {
+  str = trim(str);        // Remove any whitespace
+  str = ltrim(str, "0");  // Remove any leading 0's
+  if (str == "") {
+    return 0;
+  }
+
+  char *end;
+  char *cstr = const_cast<char *>(str.c_str());
+  unsigned long long int l;
+  errno = 0;
+  l = strtoull(cstr, &end, base);
+  if (errno == ERANGE && l == ULLONG_MAX) {
+    cout << "ERROR: String conversion was out of the range of a UInt64 - "
+         << str << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+  if (*cstr == '\0' || *end != '\0') {
+    cout << "ERROR: String is not convertible to a UInt64 - " << str << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+  return (uint64_t)l;
+}
+
+/// Convert the given number to a hex string
+///
+///   toHex(255);    // => "ff"
+string toHex(const uint64_t &val) {
+  stringstream stream;
+  stream << hex << val;
+  return stream.str();
+}
+
+/// Convert the given number to a string
+///
+///   toStr(255);    // => "255"
+string toStr(const uint64_t &val) {
+  stringstream stream;
+  stream << val;
+  return stream.str();
+}
+
+/// Uppercase the given string
+///
+///   upcase("ff");  // => "FF"
+string upcase(string base) {
+  transform(base.begin(), base.end(), base.begin(), ::toupper);
+  return base;
+}
+
+/// Lowercase the given string
+///
+///   downcase("FF");  // => "ff"
+string downcase(string base) {
+  transform(base.begin(), base.end(), base.begin(), ::tolower);
+  return base;
+}
+
+/// Extend the string to the given size, padding with the given character on the
+/// left
+///
+///   lpad("FF", 4, '0');  // => "00FF"
+string lpad(string base, int length, char fill) {
+  stringstream padded;
+  padded << right << setw(length) << setfill(fill) << base;
+  return padded.str();
+}
+
+/// Extend the string to the given size, padding with the given character on the
+/// right
+///
+///   rpad("FF", 4, ' ');  // => "FF  "
+string rpad(string base, int length, char fill) {
+  stringstream padded;
+  padded << left << setw(length) << setfill(fill) << base;
+  return padded.str();
+}
+
+/// Returns true if the given number is even
+bool isEven(uint64_t number) { return number % 2 == 0; }
+
+/// Returns true if the given number is odd
+bool isOdd(uint64_t number) { return number % 2 != 0; }
+
+/// Overlays the given data on the given pin, starting from the first vector of
+/// the given pattern
+/// must provide the waveform indices used for output high and low
+void overlaySubroutineOutput(string subroutinePattern, string pin,
+                             uint64_t data, int size, int loOutputIndex,
+                             int hiOutputIndex) {
+  string p = extractPinsFromGroup(pin);
+  // string pat = getTdiLabelName(subroutinePattern);
+  string pat = subroutinePattern;
+  VEC_LABEL_EDIT ov(pat, p);
+
+  // Need to use a vector here so the size can be determined at runtime
+  vector<VECTOR_DATA> vecData(size);
+
+  for (int i = 0; i < size; i++) {
+    int val = (data & (1 << i)) >> i;
+    if (val == 1)
+      val = hiOutputIndex;
+    else
+      val = loOutputIndex;
+    VECTOR_DATA v = {i, val};
+    vecData[i] = v;
+  }
+
+  // However the downloadUserVectors function only accepts an array, so use this
+  // trick
+  // to create an array instance that points to the vector data
+  VECTOR_DATA *vecDataArray = &vecData[0];
+
+  ov.downloadUserVectors(vecDataArray, size);
+}
+
+/// Overlays the given data on the given pin, starting from the first vector of
+/// the given pattern
+void overlaySubroutine(string subroutinePattern, string pin, uint64_t data,
+                       int size) {
+  string p = extractPinsFromGroup(pin);
+  string pat = subroutinePattern;
+  VEC_LABEL_EDIT ov(pat, p);
+
+  // Need to use a vector here so the size can be determined at runtime
+  vector<VECTOR_DATA> vecData(size);
+
+  for (int i = 0; i < size; i++) {
+    int val = (data & (1 << i)) >> i;
+    VECTOR_DATA v = {i, val};
+    vecData[i] = v;
+  }
+
+  // However the downloadUserVectors function only accepts an array, so use this
+  // trick
+  // to create an array instance that points to the vector data
+  VECTOR_DATA *vecDataArray = &vecData[0];
+
+  ov.downloadUserVectors(vecDataArray, size);
+}
+
+/// Same as overlaySubroutine but the data is applied in reverse order
+void reverseOverlaySubroutine(string subroutinePattern, string pin,
+                              uint64_t data, int size) {
+  string p = extractPinsFromGroup(pin);
+  string pat = subroutinePattern;
+  VEC_LABEL_EDIT ov(pat, p);
+
+  // Need to use a vector here so the size can be determined at runtime
+  vector<VECTOR_DATA> vecData(size);
+
+  for (int i = 0; i < size; i++) {
+    int j = size - 1 - i;
+    int val = (data & (1 << j)) >> j;
+    VECTOR_DATA v = {i, val};
+    vecData[i] = v;
+  }
+
+  // However the downloadUserVectors function only accepts an array, so use this
+  // trick
+  // to create an array instance that points to the vector data
+  VECTOR_DATA *vecDataArray = &vecData[0];
+
+  ov.downloadUserVectors(vecDataArray, size);
+}
+
+/// Returns the number of 1's (bits that are set) in the given 32-bit number
+int numberOfOnes(uint32_t i) {
+  i = i - ((i >> 1) & 0x55555555);
+  i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
+  return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+
+/// Returns the number of 0's (bits that are not set) in the given 32-bit number
+int numberOfZeros(uint32_t i) { return 32 - numberOfOnes(i); }
+
+double calculateFrequency(const ARRAY_I &captureData, double periodInNs) {
+  int iFreqCount;
+  double dFreq_MHz;
+
+  iFreqCount = 0;
+  for (int j = 0; j < captureData.size() - 1; j++) {
+    if ((captureData[j + 1] - captureData[j]) == 1) {
+      iFreqCount++;
+    }
+  }
+  dFreq_MHz = iFreqCount / ((periodInNs / 1000) * captureData.size());
+  return dFreq_MHz * 1000000;
+}
+
+double calculatePeriod(const ARRAY_I &captureData, double periodInNs) {
+  return 1 / calculateFrequency(captureData, periodInNs);
+}
+
+/// Call to wait for all SMC threads to complete, supply the max amount of
+/// seconds to wait
+void synchronize(double timeout) {
+  bool ok;
+  int site = CURRENT_SITE_NUMBER();
+
+  if (timeout) {
+    ok = SMC_SYNCHRONIZE(timeout s);
+  } else {
+    ok = SMC_SYNCHRONIZE();
+  }
+
+  if (!ok) {
+    cout << "ERROR: All SMC threads not complete after " << timeout
+         << " second(s) on site " << site << endl;
+    ERROR_EXIT(TM::EXIT_FLOW);
+  }
+}
+
+// Check to see if a pin exists in current pin config
+bool pinExists(const string &pinName) {
+  stringstream fw_command;
+  string fw_answer;
+  bool result;
+
+  fw_command << "dfpn? (" << pinName << ")" << endl;
+
+  FW_TASK(fw_command.str(), fw_answer);
+  fw_command.str(std::string());
+
+  result = !(fw_answer.empty());
+  return result;
+}
+
+/// Supply a pin alias name and get the name of the physical pin returned
+string extractPinsFromGroup(const string &groupname) {
+  string pinlist;
+
+  try {
+    pinlist = PinUtility.createPinListFromPinNames(
+        PinUtility.getDigitalPinNamesFromPinList(
+            groupname, TM::ALL_DIGITAL, true, true,
+            PIN_UTILITY::DEFINITION_ORDER));
+  } catch (...) {
+    cout << "ERROR: Pingroup " << groupname << " not found." << endl;
+    ERROR_EXIT(TM::ABORT_FLOW);
+  }
+
+  return pinlist;
+}
+
+// Initializes the site objects that are used to store the ECID, this should be
+// called at
+// the start of the test flow if using the Origen.site API
+void initializeSites() {
+  INT num_of_sites;
+  ARRAY_I sites;
+
+  ON_FIRST_INVOCATION_BEGIN();
+
+  num_of_sites = GET_CONFIGURED_SITES(sites);
+
+  // Leave an empty space at 0, easier then to fetch by site number (which start
+  // at 1)
+  Origen::Sites.resize(num_of_sites + 1, Origen::Site(0));
+
+  Origen::Time::initTime();  // take snapshot of current time for later use
+
+  ON_FIRST_INVOCATION_END();
+
+  // Instantiate a new site object and save it in the global site array
+  Origen::Site site(CURRENT_SITE_NUMBER());
+
+  Origen::Sites[CURRENT_SITE_NUMBER()] = site;
+}
+
+double getUnitMultiplier(const string &units) {
+  double mult;
+
+  if (units.find("nA") != string::npos) {
+    mult = 1e9;
+  } else if (units.find("uA") != string::npos) {
+    mult = 1e6;
+  } else if (units.find("mA") != string::npos) {
+    mult = 1e3;
+  } else if (units.find("A") != string::npos) {
+    mult = 1;
+  } else if (units.find("nV") != string::npos) {
+    mult = 1e9;
+  } else if (units.find("uV") != string::npos) {
+    mult = 1e6;
+  } else if (units.find("mV") != string::npos) {
+    mult = 1e3;
+  } else if (units.find("V") != string::npos) {
+    mult = 1;
+  } else if (units.find("Kohm") != string::npos) {
+    mult = 1e-3;
+  } else if (units.find("ns") != string::npos) {
+    mult = 1e9;
+  } else if (units.find("us") != string::npos) {
+    mult = 1e6;
+  } else if (units.find("ms") != string::npos) {
+    mult = 1e3;
+  } else if (units.find("s") != string::npos) {
+    mult = 1;
+  } else if (units.find("KHz") != string::npos) {
+    mult = 1e-3;
+  } else if (units.find("MHz") != string::npos) {
+    mult = 1e-6;
+  } else {
+    mult = 1;
+  }
+
+  return mult;
+}
+
+string getLabelFromBurst(const string &burst, const string &port) {
+  ////////////////////////////////////////////////////////////////////
+  // Note this function will always return the first label in a burst
+  ////////////////////////////////////////////////////////////////////
+  string answer;
+  stringstream ss;
+
+  ss << "sqpg? \"" << burst << "\",(" << port << ")" << endl;
+
+  FW_TASK(ss.str(), answer);
+
+  ss.str("");
+
+  int fc = answer.find_first_of("\"") + 1;
+  int len = answer.find_last_of("\"") - fc;
+
+  return (answer.substr(fc, len));
+}
+
+string checksum16bits(const string &mystring) {
+  long flag;
+  long poly = 0xa001;
+  long crc = 0xffff;
+  string crc16;
+
+  vector<char> ch(mystring.begin(), mystring.end());
+
+  for (unsigned int i = 0; i < ch.size(); i++) {
+    crc ^= static_cast<int>(ch[i]);
+
+    for (unsigned int j = 0; j < 8; j++) {
+      flag = crc & long(0x1);
+      crc /= long(0x2);
+
+      if (flag == 1) crc ^= poly;
+    }
+  }
+
+  unsigned n;
+  stringstream ss;
+  ss << hex << (crc & long(0xffff));
+  ss >> n;
+  ss.str("");
+
+  bitset<16> bstr(n);
+
+  crc16 = bstr.to_string();
+
+  return crc16;
+}
+}