WasatchVCPP.h

Go to the documentation of this file.

 
#pragma once
 
//                                                                            //
//                                   C API                                    //
//                                                                            //
 
// This will ensure that when the LIBRARY is being built, it will EXPORT the
// DLL symbols, and when the library is being USED (this header is being 
// included into a customer application which is being compiled), the DLL
// symbols will be IMPORTED.
#if _WINDOWS
    #ifdef WASATCHVCPPLIB_EXPORTS
        #define DLL_API __declspec(dllexport)
    #else
        #define DLL_API __declspec(dllimport)
    #endif
#else
    #define DLL_API
#endif
 
// all functions should return one of these codes unless indicated otherwise
 
#define WP_SUCCESS                      0     
#define WP_ERROR                       -1     
#define WP_ERROR_INVALID_SPECTROMETER  -2     
#define WP_ERROR_INSUFFICIENT_STORAGE  -3     
#define WP_ERROR_NO_LASER              -4     
#define WP_ERROR_NOT_INGAAS            -5     
#define WP_ERROR_INVALID_GAIN          -256   
#define WP_ERROR_INVALID_TEMPERATURE   -999   
#define WP_ERROR_INVALID_OFFSET        -32768 
 
// supported log levels
#define WP_LOG_LEVEL_DEBUG              0
#define WP_LOG_LEVEL_INFO               1
#define WP_LOG_LEVEL_ERROR              2
#define WP_LOG_LEVEL_NEVER              3
 
// Although we're using a C++ compiler (as the library is written in C++), we 
// want these function symbols to be compiled with C linkage (no C++ mangling). 
// This will ensure that the broadest range of customer languages, compilers and
// toolchains can link to the library.
extern "C"
{
    // Utility
 
    DLL_API int wp_set_logfile_path(const char* pathname, int len);
 
    DLL_API int wp_set_log_level(int level);
 
    DLL_API int wp_log_debug(const char* msg, int len);
 
    DLL_API int wp_get_library_version(char* value, int len);
 
    DLL_API int wp_get_vignetted_spectrum_length(int specIndex);
 
    DLL_API int wp_apply_raman_intensity_factors(int specIndex, double* spectrum, int spectrum_len, double* factors, int factors_len, int start_pixel, int end_pixel);
 
    DLL_API int wp_has_srm_calibration(int specIndex);
 
    DLL_API int wp_get_raman_intensity_factors(int specIndex, double* factors, int factorsLen);
 
    // Lifecycle
 
    DLL_API int wp_open_all_spectrometers();
 
    DLL_API int wp_get_number_of_spectrometers();
 
    DLL_API int wp_close_all_spectrometers();
 
    DLL_API int wp_close_spectrometer(int specIndex);
 
    DLL_API void wp_destroy_driver();
 
    // EEPROM 
 
    DLL_API int wp_get_eeprom_field_count(int specIndex);
 
    DLL_API int wp_get_eeprom_field_name(int specIndex, int index, char *value, int len);
 
    DLL_API int wp_get_eeprom(int specIndex, const char** names, const char** values, int len);
 
    DLL_API int wp_get_eeprom_page(int specIndex, int page, unsigned char* buf, int len);
 
    DLL_API int wp_write_eeprom_page(int specIndex, int pageIndex, unsigned char* data, int dataLen);
 
    DLL_API int wp_get_eeprom_field(int specIndex, const char* name, char* value, int len);
 
    // Convenience accessors
 
    DLL_API int wp_get_pixels(int specIndex);
 
    DLL_API int wp_get_model(int specIndex, char* value, int len);
 
    DLL_API int wp_get_serial_number(int specIndex, char* value, int len);
 
    DLL_API int wp_get_wavelengths(int specIndex, double* wavelengths, int len);
 
    DLL_API int wp_get_wavelengths_float(int specIndex, float* wavelengths, int len);
 
    DLL_API int wp_get_wavenumbers(int specIndex, double* wavenumbers, int len);
 
    DLL_API int wp_get_wavenumbers_float(int specIndex, float* wavenumbers, int len);
 
    // Acquisition
 
    DLL_API int wp_get_spectrum(int specIndex, double* spectrum, int len);
 
    DLL_API int wp_get_spectrum_float(int specIndex, float* spectrum, int len);
 
    DLL_API int wp_cancel_operation(int specIndex, int blocking);
 
    DLL_API int wp_set_max_timeout_ms(int specIndex, int maxTimeoutMS);
 
    DLL_API int wp_get_max_timeout_ms(int specIndex);
 
    // Opcodes
 
    DLL_API int wp_set_integration_time_ms(int specIndex, unsigned long ms);
 
    DLL_API int wp_set_laser_enable(int specIndex, int value);
 
    DLL_API int wp_set_laser_power_perc(int specIndex, float percent);
 
    DLL_API int wp_set_laser_power_mW(int specIndex, float power);
 
    DLL_API int wp_set_detector_gain(int specIndex, float value);
 
    DLL_API int wp_set_detector_gain_odd(int specIndex, float value);
    
    DLL_API int wp_set_detector_offset(int specIndex, int value);
 
    DLL_API int wp_set_detector_offset_odd(int specIndex, int value);
 
    DLL_API int wp_set_detector_tec_enable(int specIndex, int value);
 
    DLL_API int wp_set_detector_tec_setpoint_deg_c(int specIndex, int value);
 
    DLL_API int wp_set_high_gain_mode_enable(int specIndex, int value);
 
    DLL_API int wp_get_firmware_version(int specIndex, char* value, int len);
 
    DLL_API int wp_get_fpga_version(int specIndex, char* value, int len);
 
    DLL_API float wp_get_detector_temperature_deg_c(int specIndex);
 
    DLL_API long wp_get_integration_time_ms(int specIndex);
 
    DLL_API int wp_get_laser_enable(int specIndex);
 
    DLL_API float wp_get_detector_gain(int specIndex);
 
    DLL_API float wp_get_detector_gain_odd(int specIndex);
 
    DLL_API int wp_get_detector_offset(int specIndex);
 
    DLL_API int wp_get_detector_offset_odd(int specIndex);
 
    DLL_API int wp_get_detector_tec_enable(int specIndex);
 
    DLL_API int wp_get_detector_tec_setpoint_deg_c(int specIndex);
 
    DLL_API int wp_get_high_gain_mode_enable(int specIndex);
 
    DLL_API int wp_send_control_msg(int specIndex, 
                           unsigned char bRequest, 
                           unsigned int wValue,
                           unsigned int wIndex,
                           unsigned char* data,
                           int len);
 
    DLL_API int wp_read_control_msg(int specIndex, 
                                    unsigned char bRequest, 
                                    unsigned int wIndex,
                                    unsigned char* data,
                                    int len);
}
 
//                                                                            //
//                                  C++ API                                   //
//                                                                            //
 
// We only want the following classes declared (and defined, since they're 
// inline) if this file is being #included from "calling customer code" on the
// client side.  Therefore, we wrap it in the following #ifndef, which prevents
// the block being processed if we're actually compiling the WasatchVCPP DLL
// itself.
//
// It is important to prevent these from being compiled into the DLL, because
// otherwise the customer could end up with two "copies" of the same classes
// (one compiled into the DLL, the other instantiated into their own application
// when they include this header).  That could create linkage collisions down
// the road.  It MIGHT not be an issue, as long as we don't "dllexport" these
// declarations (and we're not), but I'd rather not take the chance.
//
// Another reason why we don't want these classes compiled into the DLL is
// because, for ABI boundary reasons, they'd be unusable to the customer
// that way.  To be useable by the customer application, C++ types and STL 
// containers must be instantiated and compiled directly into the client
// executable.
// 
// See README_ARCHITECTURE.md for more.
 
#ifndef WASATCHVCPPLIB_EXPORTS
 
#include <vector>
#include <string>
#include <map>
 
namespace WasatchVCPP
{
    namespace Proxy
    {
        //
        //                        Spectrometer Proxy
        //
 
        class Spectrometer
        {
            // Public methods
            public:
 
                Spectrometer(int specIndex)
                {
                    this->specIndex = specIndex;
 
                    readEEPROMFields();
 
                    pixels = wp_get_pixels(specIndex); // or eepromFields["activePixelsHoriz"]
                    if (pixels <= 0)
                        return;
 
                    // pre-allocate a buffer for reading spectra
                    spectrumBuf.resize(pixels);
 
                    model = eepromFields["model"];
                    serialNumber = eepromFields["serialNumber"];
 
                    wavelengths.resize(pixels);
                    wp_get_wavelengths(specIndex, &wavelengths[0], pixels);
 
                    excitationNM = (float)atof(eepromFields["excitationNM"].c_str());
                    if (excitationNM > 0)
                    {
                        wavenumbers.resize(pixels);
                        wp_get_wavenumbers(specIndex, &wavenumbers[0], pixels);
                    }
                }
 
                ~Spectrometer()
                {
                    close();
                }
 
                bool close()
                {
                    bool success = false;
                    if (specIndex >= 0)
                    {
                        success = (WP_SUCCESS == wp_close_spectrometer(specIndex));
                        specIndex = -1;
 
                        wavelengths.clear();
                        wavenumbers.clear();
                        eepromFields.clear();
                    }
 
                    return success;
                }
 
            // Public attributes
            public:
                int specIndex;              
                int pixels;                 
                std::string model;          
                std::string serialNumber;   
 
                std::map<std::string, std::string> eepromFields;
 
                std::vector<double> wavelengths;    
                std::vector<double> wavenumbers;    
                float excitationNM;                 
 
            // Public methods
            public:
                bool setIntegrationTimeMS(unsigned long ms)
                { return WP_SUCCESS == wp_set_integration_time_ms(specIndex, ms); }
 
                bool setLaserEnable(bool flag)
                { return WP_SUCCESS == wp_set_laser_enable(specIndex, flag); }
 
                bool setDetectorGain(float value)
                { return WP_SUCCESS == wp_set_detector_gain(specIndex, value); }
 
                bool setLaserPowerPerc(float value)
                {
                    return WP_SUCCESS == wp_set_laser_power_perc(specIndex, value);
                }
 
                bool setLaserPowermW(float value)
                {
                    return WP_SUCCESS == wp_set_laser_power_mW(specIndex, value);
                }
 
                bool setDetectorGainOdd(float value)
                { return WP_SUCCESS == wp_set_detector_gain_odd(specIndex, value); }
 
                bool setDetectorOffset(int16_t value)
                { return WP_SUCCESS == wp_set_detector_offset(specIndex, value); }
 
                bool setDetectorOffsetOdd(int16_t value)
                { return WP_SUCCESS == wp_set_detector_offset_odd(specIndex, value); }
 
                bool setDetectorTECEnable(bool flag)
                { return WP_SUCCESS == wp_set_detector_tec_enable(specIndex, flag ? 1 : 0); }
 
                bool setDetectorTECSetpointDegC(int value)
                { return WP_SUCCESS == wp_set_detector_tec_setpoint_deg_c(specIndex, value); }
 
                bool setHighGainMode(bool flag)
                { return WP_SUCCESS == wp_set_high_gain_mode_enable(specIndex, flag ? 1 : 0); }
 
                float getDetectorTemperatureDegC()
                { return wp_get_detector_temperature_deg_c(specIndex); }
 
                long getIntegrationTimeMS() { return wp_get_integration_time_ms(specIndex); }
 
                bool getLaserEnable() { return 0 != wp_get_laser_enable(specIndex); }
 
                float getDetectorGain() { return wp_get_detector_gain(specIndex); }
 
                float getDetectorGainOdd() { return wp_get_detector_gain_odd(specIndex); }
 
                int getDetectorOffset() { return wp_get_detector_offset(specIndex); }
 
                int getDetectorOffsetOdd() { return wp_get_detector_offset_odd(specIndex); }
 
                bool getDetectorTECEnable() { return 0 != wp_get_detector_tec_enable(specIndex); }
 
                int getDetectorTECSetpointDegC() { return wp_get_detector_tec_setpoint_deg_c(specIndex); }
 
                bool getHighGainModeEnable() { return 0 != wp_get_high_gain_mode_enable(specIndex); }
 
                int sendControlMsg(uint8_t bRequest, uint16_t wValue, uint16_t wIndex, uint8_t* data, int len)
                { return wp_send_control_msg(specIndex, bRequest, wValue, wIndex, data, len); }
 
                int readControlMsg(uint8_t bRequest, uint16_t wIndex, uint8_t* data, int len)
                { return wp_read_control_msg(specIndex, bRequest, wIndex, data, len); }
 
                bool setMaxTimeoutMS(int maxTimeoutMS)
                { return WP_SUCCESS == wp_set_max_timeout_ms(specIndex, maxTimeoutMS); }
 
                int getMaxTimeoutMS()
                { return wp_get_max_timeout_ms(specIndex); }
 
                bool cancelOperation(bool blocking=false)
                { return WP_SUCCESS == wp_cancel_operation(specIndex, blocking ? 1 : 0); }
 
                std::string getFirmwareVersion()
                {
                    char buf[16];
                    wp_get_firmware_version(specIndex, buf, sizeof(buf));
                    return std::string(buf);
                }
 
                std::string getFPGAVersion()
                {
                    char buf[16];
                    wp_get_fpga_version(specIndex, buf, sizeof(buf));
                    return std::string(buf);
                }
 
                std::vector<double> getSpectrum()
                {
                    std::vector<double> result;
                    if (pixels > 0)
                        if (WP_SUCCESS == wp_get_spectrum(specIndex, &(spectrumBuf[0]), pixels))
                            result = spectrumBuf;
                    return result;
                }
 
                std::vector<uint8_t> getEEPROMPage(int page)
                {
                    const int len = 64;
                    std::vector<uint8_t> result;
                    uint8_t buf[len] = { 0 };
 
                    if (WP_SUCCESS != wp_get_eeprom_page(specIndex, page, buf, len))
                        return result;
 
                    result.resize(len);
                    for (int i = 0; i < len; i++)
                        result[i] = buf[i];
                    return result;
                }
 
                std::string getEEPROMFieldName(int index)
                {
                    char buf[64] = { 0 };
                    if (WP_SUCCESS != wp_get_eeprom_field_name(specIndex, index, buf, sizeof(buf)))
                        return std::string();
                    return std::string(buf);
                }
 
                std::vector<float> getWavecalCoeffs()
                {
                    std::vector<float> v;
                    for (int i = 0; i < 5; i++)
                        v.push_back(std::stof(eepromFields["wavecalCoeffs[" + std::to_string(i) + "]"]));
                    return v;
                }
 
            private:
                bool readEEPROMFields()
                {
                    int count = wp_get_eeprom_field_count(specIndex);
                    if (count <= 0)
                        return false;
 
                    const char** names  = (const char**)malloc(count * sizeof(const char*));
                    const char** values = (const char**)malloc(count * sizeof(const char*));
 
                    if (WP_SUCCESS != wp_get_eeprom(specIndex, names, values, count))
                    {
                        free(names);
                        free(values);
                        return false;
                    }
 
                    for (int i = 0; i < count; i++)
                        eepromFields.insert(std::make_pair(std::string(names[i]), std::string(values[i])));
 
                    free(names);
                    free(values);
                    return true;
                }
                std::vector<double> spectrumBuf;
        };
 
        // 
        //                               Proxy Driver
        //
 
        class Driver
        {
            // Public methods
            public:
                Driver() {}
 
                bool setLogfile(const std::string& pathname)
                { return WP_SUCCESS == wp_set_logfile_path(pathname.c_str(), (int)pathname.size()); }
 
                bool setLogLevel(int level)
                { return WP_SUCCESS == wp_set_log_level(level); }
 
                std::string getLibraryVersion()
                {
                    char buf[16];
                    wp_get_library_version(buf, sizeof(buf));
                    return std::string(buf);
                }
 
                int openAllSpectrometers()
                {
                    spectrometers.clear();
 
                    auto enumeratedCount = wp_open_all_spectrometers();
                    if (enumeratedCount <= 0)
                        return 0;
 
                    int validCount = 0;
                    for (int index = 0; index < enumeratedCount; index++)
                    {
                        auto pixels = wp_get_pixels(index);
                        if (pixels > 0)
                        {
                            auto spec = new Proxy::Spectrometer(index);
                            spectrometers.insert(std::make_pair(validCount, spec));
                            validCount++;
                        }
                    }
 
                    return validCount;
                }
 
                Spectrometer* getSpectrometer(int index)
                {
                    auto iter = spectrometers.find(index);
                    if (iter == spectrometers.end())
                        return nullptr;
 
                    return iter->second;
                }
 
                bool closeAllSpectrometers()
                {
                    for (auto iter = spectrometers.begin(); iter != spectrometers.end(); iter++)
                    {
                        delete iter->second;
                        iter->second = nullptr;
                    }
                    spectrometers.clear();
 
                    return WP_SUCCESS == wp_close_all_spectrometers();
                }
 
                void destroy()
                {
                    closeAllSpectrometers();
                    wp_destroy_driver();
                }
 
            // Public attributes
            public:                    
 
                int numberOfSpectrometers = 0;
 
            // Private attributes
 
            private:
                std::map<int, Spectrometer*> spectrometers;
        };
    }
}
#endif