int getPixels()
{
int retval = 0;
int error = 0;
if (specIndex < 0)
{
return(retval);
}
bool ok = mut.WaitOne(2);
if (!ok)
{
return(0);
}
retval = SeaBreezeWrapper.seabreeze_get_formatted_spectrum_length(specIndex, ref error);
mut.ReleaseMutex();
if (error != 0)
{
logger.queue("error getting pixel count (error = {0})", error);
return(0);
}
return(retval);
}
string getModel()
{
int error = 0;
if (specIndex < 0)
{
return(null);
}
byte[] buf = new byte[16];
bool ok = mut.WaitOne(2);
if (!ok)
{
return(null);
}
SeaBreezeWrapper.seabreeze_get_model(specIndex, ref error, ref buf[0], buf.Length);
mut.ReleaseMutex();
if (error != 0)
{
logger.queue("error getting model (error = {0})", error);
return(null);
}
return(byteToString(buf));
}
double[] readWavelengths()
{
if (specIndex < 0)
{
return(null);
}
double[] wl = new double[pixels];
int error = 0;
bool ok = mut.WaitOne(2);
if (!ok)
{
return(null);
}
SeaBreezeWrapper.seabreeze_get_wavelengths(specIndex, ref error, ref wl[0], pixels);
mut.ReleaseMutex();
if (error != 0)
{
logger.queue("Error calling readWavelengths(): errorCode = {0}", error);
specIndex = -1;
return(null);
}
return(wl);
}
public string GetName()
{
string result = "Not Connected";
if (isActive)
{
Int32 myErrorCode = 0;
Int32 errorStringLength = SeaBreezeWrapper.seabreeze_get_error_string_maximum_length();
byte[] errorStringBuffer = new byte[errorStringLength];
Int32 modelStringLength = SeaBreezeWrapper.seabreeze_get_model_string_maximum_length();
byte[] myModelTypeBuffer = new byte[modelStringLength];
int bytesInBuffer = SeaBreezeWrapper.seabreeze_get_model(SEABREEZE_ID, ref myErrorCode, ref myModelTypeBuffer[0], modelStringLength);
if (myErrorCode != 0)
{
bytesInBuffer = SeaBreezeWrapper.seabreeze_get_error_string(myErrorCode, ref errorStringBuffer[0], errorStringLength);
string myErrorString = "Exception getting model description: " + System.Text.Encoding.Default.GetString(errorStringBuffer);
throw (new Exception(myErrorString));
}
result = System.Text.Encoding.UTF8.GetString(myModelTypeBuffer).TrimEnd((char)0);
}
return(result);
}
public string getSpectrometerType()
{
string result = null;
if (!initialized)
{
return(result);
}
mut.WaitOne();
try
{
byte[] slot = new byte[SeaBreezeWrapper.SLOT_LENGTH];
int error = 0;
SeaBreezeWrapper.seabreeze_get_model(specIndex, ref error, ref slot[0], SeaBreezeWrapper.SLOT_LENGTH);
if (checkSeaBreezeError("get_spectrometer_type", error))
{
result = byteToString(slot);
}
}
catch (Exception e)
{
logger.log("Error getting spectrometer type: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public string getVersion()
{
string result = null;
mut.WaitOne();
const int MAX_VERSION_LEN = 80;
try
{
byte[] version = new byte[MAX_VERSION_LEN];
int error = 0;
SeaBreezeWrapper.seabreeze_get_api_version_string(ref version[0], version.Length);
if (checkSeaBreezeError("get_api_version_string", error))
{
result = byteToString(version);
}
}
catch (Exception e)
{
logger.log("Error getting version string: {0}", e.Message);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public bool setTriggerMode(int mode)
{
bool result = false;
if (!initialized)
{
return(result);
}
mut.WaitOne();
try
{
int error = 0;
SeaBreezeWrapper.seabreeze_set_trigger_mode(specIndex, ref error, mode);
result = checkSeaBreezeError("set_integration_time_microsec", error);
}
catch (Exception e)
{
logger.log("Error setting trigger mode: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public bool open()
{
initialized = false;
opened = false;
wavelengths = null;
int error = 0;
SeaBreezeWrapper.seabreeze_open_spectrometer(specIndex, ref error);
if (!checkSeaBreezeError("open_spectrometer", error))
{
return(false);
}
opened = true;
pixels = SeaBreezeWrapper.seabreeze_get_formatted_spectrum_length(specIndex, ref error);
if (!checkSeaBreezeError("get_formatted_spectrum_length", error))
{
return(false);
}
double[] tmp = new double[pixels];
SeaBreezeWrapper.seabreeze_get_wavelengths(specIndex, ref error, ref tmp[0], pixels);
if (!checkSeaBreezeError("get_wavelengths", error))
{
return(false);
}
wavelengths = tmp;
initialized = true;
return(initialized);
}
public int[] getEDCIndices()
{
int[] result = null;
mut.WaitOne();
try
{
int error = 0;
int[] buf = new int[64];
int count = SeaBreezeWrapper.seabreeze_get_electric_dark_pixel_indices(specIndex, ref error, ref buf[0], 64);
result = new int[count];
for (int i = 0; i < count; i++)
{
result[i] = buf[i];
}
}
catch (Exception e)
{
logger.log("Error getting EDC indices: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public bool close()
{
bool result = false;
opened = false;
if (!initialized)
{
return(result);
}
mut.WaitOne();
try
{
int error = 0;
SeaBreezeWrapper.seabreeze_close_spectrometer(specIndex, ref error);
result = checkSeaBreezeError("close_spectrometer", error);
}
catch (Exception e)
{
logger.log("Error closing spectrometer: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public double getCollectionArea()
{
double result = -1;
mut.WaitOne();
try
{
int error = 0;
double area = SeaBreezeWrapper.seabreeze_read_irrad_collection_area(specIndex, ref error);
if (checkSeaBreezeError("read_irrad_collection_area", error))
{
result = area;
}
}
catch (Exception e)
{
logger.log("Error getting collection area: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public double[] getIrradianceCalibration()
{
double[] result = null;
mut.WaitOne();
try
{
int error = 0;
float[] irrad_f = new float[pixels];
SeaBreezeWrapper.seabreeze_read_irrad_calibration(specIndex, ref error, ref irrad_f[0], pixels);
if (checkSeaBreezeError("read_irrad_calibration", error))
{
result = new double[pixels];
Array.Copy(irrad_f, result, pixels);
}
}
catch (Exception e)
{
logger.log("Error getting irradiance calibration: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public bool setIntegrationTimeMilliseconds(int ms)
{
bool result = false;
if (!initialized)
{
return(result);
}
mut.WaitOne();
try
{
int error = 0;
SeaBreezeWrapper.seabreeze_set_integration_time_microsec(specIndex, ref error, (long)ms * 1000);
result = checkSeaBreezeError("set_integration_time_microsec", error);
}
catch (Exception e)
{
logger.log("Error setting integration time: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public string getSerialNumber()
{
string result = null;
if (!initialized)
{
return(result);
}
mut.WaitOne();
try
{
byte[] slot = new byte[SeaBreezeWrapper.SLOT_LENGTH];
int error = 0;
SeaBreezeWrapper.seabreeze_get_serial_number(specIndex, ref error, ref slot[0], SeaBreezeWrapper.SLOT_LENGTH);
if (checkSeaBreezeError("get_serial_number", error))
{
result = byteToString(slot);
}
}
catch (Exception e)
{
logger.log("Error getting serial number: {0}", e.Message);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public double[] getNLCCoeffs()
{
double[] result = null;
if (!initialized)
{
return(result);
}
mut.WaitOne();
try
{
double[] t = new double[8];
int error = 0;
for (int i = 0; i <= 7; i++)
{
byte[] buf = new byte[SeaBreezeWrapper.SLOT_LENGTH];
int bytes_read = SeaBreezeWrapper.seabreeze_read_eeprom_slot(
specIndex, ref error, 6 + i, ref buf[0], SeaBreezeWrapper.SLOT_LENGTH);
t[i] = Convert.ToDouble(byteToString(buf));
}
result = t;
}
catch (Exception e)
{
logger.log("Error getting NLC: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public bool init()
{
int error = 0;
int openErr = SeaBreezeWrapper.seabreeze_open_spectrometer(0, ref error);
if (openErr != 0)
{
logger.queue("ERROR: SeaBreeze could not open first spectrometer");
return(false);
}
Thread.Sleep(100); // Testing...
numberOfSpectrometers = 1;
specIndex = 0;
logger.queue("Found {0} spectrometers", numberOfSpectrometers);
if (numberOfSpectrometers < 1)
{
logger.queue("ERROR: no spectrometers found");
return(false);
}
if (numberOfSpectrometers > 1)
{
logger.queue("WARNING: defaulting to first-detected spectrometer");
}
////////////////////////////////////////////////////////////////////
// initialize metadata for each spectrometer
////////////////////////////////////////////////////////////////////
pixels = getPixels();
wavelengths = readWavelengths();
serialNumber = getSerialNumber();
modelName = getModel();
////////////////////////////////////////////////////////////////////
// init GPIO
////////////////////////////////////////////////////////////////////
gpio = new FeatureControllerGPIO();
gpio.init();
gpio.setCacheEnabled(true);
////////////////////////////////////////////////////////////////////
// finished
////////////////////////////////////////////////////////////////////
logger.queue("Spectrometer at index {0} is a {1} with serial {2} and {3} pixels from {4:0.00} to {5:0.00}nm",
specIndex, modelName, serialNumber, pixels, wavelengths[0], wavelengths[wavelengths.Length - 1]);
return(true);
}
// NO INTERNAL MUTEX! Caller must synchronize
public bool writeUSB(byte[] data)
{
int error = 0;
string debug = "";
for (int i = 0; i < data.Length; i++)
{
debug += String.Format(" 0x{0:x2}", data[i]);
}
logger.log(">> {0}", debug);
SeaBreezeWrapper.seabreeze_write_usb(specIndex, ref error, USB_TX_ENDPOINT, ref data[0], data.Length);
return(error == 0);
}
// NO INTERNAL MUTEX! Caller must synchronize
public bool readUSB(ref byte[] buffer)
{
int errorCode = 0;
SeaBreezeWrapper.seabreeze_read_usb(specIndex, ref errorCode, USB_RX_ENDPOINT, ref buffer[0], buffer.Length);
string debug = "";
for (int i = 0; i < buffer.Length; i++)
{
debug += String.Format(" 0x{0:x2}", buffer[i]);
}
logger.log("<< {0}", debug);
return(errorCode == 0);
}
// returns true if last operation was successful, false if last operation had an error
private bool checkSeaBreezeError(string operation, int errorCode)
{
if (errorCode == SeaBreezeWrapper.ERROR_SUCCESS)
{
return(true);
}
byte[] buffer = new byte[64];
SeaBreezeWrapper.seabreeze_get_error_string(errorCode, ref buffer[0], 64);
string msg = byteToString(buffer);
if (logger != null)
{
logger.log("[SeaBreeze] error during {0}: {1}", operation, msg);
}
return(false);
}
// opens the first spectrometer found. It will have a SeaBreeze ID of 0
public SeaBreezeSpectrometerClass(ListBox listBoxForLogging, ref Boolean isConnected)
{
int zero_on_success = 0;
int errorCode = 0;
logListBox = listBoxForLogging;
if (File.Exists(SeaBreezeWrapper.DLL))
{
zero_on_success = SeaBreezeWrapper.seabreeze_open_spectrometer(SEABREEZE_ID, ref errorCode);
if ((zero_on_success == 0) && (errorCode == 0))
{
isActive = true;
myName = GetName();
logListBox.Items.Add("Connected to: " + myName);
isConnected = true;
if (myName.StartsWith("FLAMEX"))
{
myTests = new FlameTestClass(logListBox, SEABREEZE_ID);
}
else if (myName.StartsWith("STS"))
{
myTests = new STSTestClass(logListBox);
}
else if (myName.StartsWith("QEPRO"))
{
myTests = new QEPROTestClass(logListBox);
}
else
{
logListBox.Items.Add(string.Format("A spectrometer test class was not found for {0}.", myName));
}
}
isConnected = isActive;
}
else
{
throw (new Exception("The DLL library link was incorrect in the SeaBreezeWrapper.cs file."));
}
}
public double[] getSpectrum()
{
double[] result = null;
mut.WaitOne();
try
{
int error = 0;
double[] spec = new double[pixels];
SeaBreezeWrapper.seabreeze_get_formatted_spectrum(specIndex, ref error, ref spec[0], pixels);
if (checkSeaBreezeError("get_formatted_spectrum", error))
{
// KLUDGE: Some spectrometers (e.g. HR4000) insert non-pixel data
// into the first few pixels of the spectrum they report, which
// we can override here to avoid confusing EDC and stray noise on
// graphs.
//
// TODO: Put in appropriate logic based on spectrometer model.
for (int i = 0; i < 5; i++)
{
spec[i] = spec[5];
}
result = spec;
}
}
catch (Exception e)
{
logger.log("Error getting spectrum: {0}", e);
}
finally
{
mut.ReleaseMutex();
}
return(result);
}
public void Close()
{
if (isActive)
{
Int32 myErrorCode = 0;
Int32 aLength = SeaBreezeWrapper.seabreeze_get_error_string_maximum_length();
byte[] myBuffer = new byte[aLength];
int totallyBogus = SeaBreezeWrapper.seabreeze_close_spectrometer(SEABREEZE_ID, ref myErrorCode);
int bytesInBuffer = SeaBreezeWrapper.seabreeze_get_error_string(myErrorCode, ref myBuffer[0], aLength);
string myErrorString = "Exception closing spectrometer: " + System.Text.Encoding.Default.GetString(myBuffer);
if (myErrorCode == 0)
{
logListBox.Items.Add("Disconnected from spectrometer.");
}
else
{
logListBox.Items.Add("Error disconnecting: " + myErrorString);
}
}
}
public void GetSerialNumber()
{
Int32 myErrorCode = 0;
Int32 errorStringLength = SeaBreezeWrapper.seabreeze_get_error_string_maximum_length();
byte[] errorStringBuffer = new byte[errorStringLength];
Int32 serialNumberStringLength = SeaBreezeWrapper.seabreeze_get_serial_number_max_length(SEABREEZE_ID, ref myErrorCode);
byte[] mySerialNumberBuffer = new byte[serialNumberStringLength];
int bytesInBuffer = SeaBreezeWrapper.seabreeze_get_serial_number(SEABREEZE_ID, ref myErrorCode, ref mySerialNumberBuffer[0], serialNumberStringLength);
if (myErrorCode != 0)
{
bytesInBuffer = SeaBreezeWrapper.seabreeze_get_error_string(myErrorCode, ref errorStringBuffer[0], errorStringLength);
string myErrorString = "Exception getting model description: " + System.Text.Encoding.Default.GetString(errorStringBuffer);
throw (new Exception(myErrorString));
}
string mySerialNumber = System.Text.Encoding.UTF8.GetString(mySerialNumberBuffer).TrimEnd((char)0);
Log("Serial Number: " + mySerialNumber);
}
public FlameTestClass(ListBox lb, int spectrometerID) : base(lb)
{
int errorCode = 0;
const int maxIndiciesCount = 32;
int [] pixelIndicies = new int[maxIndiciesCount];
uint numberOfPixels = 0;
// these commands are called when the spectrometer is initialized
Log("The Flame X sends introspective commands during initialization.");
mySpectrometerID = spectrometerID;
// even though these were called in the initialization, call again to display values.
numberOfPixels = SeaBreezeWrapper.seabreeze_get_number_of_pixels(spectrometerID, ref errorCode);
if (errorCode == SeaBreezeWrapper.ERROR_SUCCESS)
{
Log("Executed Command: 0x00110220 Get number of pixels. " + numberOfPixels.ToString());
}
else
{
Log("Failure getting pixel count: " + GetErrorDescription(errorCode));
}
int numberOfIndicies = SeaBreezeWrapper.seabreeze_get_active_pixel_indices(spectrometerID, ref errorCode, ref pixelIndicies[0], 32);
if (errorCode == SeaBreezeWrapper.ERROR_SUCCESS)
{
string indicies = "";
for (int x = 0; x < numberOfIndicies; x = x + 2)
{
indicies = indicies + "(" + pixelIndicies[x].ToString() + ", " + pixelIndicies[x + 1].ToString() + ") ";
}
Log("Executed Command: 0x00110221 Get active pixel ranges:" + indicies);
}
else
{
Log("Failure getting pixel count: " + GetErrorDescription(errorCode));
}
int opticalDarkIndex = SeaBreezeWrapper.seabreeze_get_optical_dark_pixel_indices(spectrometerID, ref errorCode, ref pixelIndicies[0], 32);
if (errorCode == SeaBreezeWrapper.ERROR_SUCCESS)
{
string indicies = "";
for (int x = 0; x < opticalDarkIndex; x = x + 2)
{
indicies = indicies + "(" + pixelIndicies[x].ToString() + ", " + pixelIndicies[x + 1].ToString() + ") ";
}
Log("Executed Command: 0x00110222 Get optical dark pixel ranges" + indicies);
}
else
{
Log("Failure getting pixel count: " + GetErrorDescription(errorCode));
}
int electricDarkPixelIndex = SeaBreezeWrapper.seabreeze_get_electric_dark_pixel_indices(spectrometerID, ref errorCode, ref pixelIndicies[0], 32);
if (errorCode == SeaBreezeWrapper.ERROR_SUCCESS)
{
string indicies = "";
for (int x = 0; x < electricDarkPixelIndex; x = x + 2)
{
indicies = indicies + "(" + pixelIndicies[x].ToString() + ", " + pixelIndicies[x + 1].ToString() + ") ";
}
Log("Executed Command: 0x00110223 Get electrical dark pixel ranges" + indicies);
}
else
{
Log("Failure getting pixel count: " + GetErrorDescription(errorCode));
}
}
public string GetErrorDescription(int errorCode)
{
int stringlength = SeaBreezeWrapper.seabreeze_get_error_string(errorCode, ref errorMessage[0], errorStringLength);
return(errorMessage.ToString());
}