Spectrometer.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef USE_LIBUSB_WIN32
#include "libusb.h"
#define WPVCPP_UDEV_TYPE usb_dev_handle
#else
//#include <libusb-1_0.h>
#include <libusb.h>
#define WPVCPP_UDEV_TYPE libusb_device_handle
#endif
 
#include "EEPROM.h"
#include "Logger.h"
 
#include <vector>
#include <mutex>
 
namespace WasatchVCPP
{
    class Driver;
 
 
    class Spectrometer
    {
        public:
            enum ErrorCodes 
            {
                Success             =  0,
                Error               = -1,
                InvalidSpectrometer = -2,
                InsufficientStorage = -3,
                NoLaser             = -4,
                NotInGaAs           = -5,
                InvalidGain         = -256,
                InvalidTemperature  = -999,
                InvalidOffset       = -32768 
            };
 
            Spectrometer(WPVCPP_UDEV_TYPE* udev, int pid, int index, Logger& logger);
            ~Spectrometer();
 
            bool close();
 
            EEPROM eeprom;
            Driver* driver = nullptr;     // still needed?
 
            // public metadata
            int pid = 0;
            int index = -1;
            std::vector<double> wavelengths;
            std::vector<double> wavenumbers;
            bool isARM();
            bool isInGaAs();
            bool isMicro();
 
            int maxTimeoutMS = 1000;
 
            // cached properties
            int pixels = 0;
            std::string firmwareVersion;
            std::string fpgaVersion;
            int integrationTimeMS = 1;
            bool laserEnabled = false;
            bool laserPowerHighResolution = true;
            bool laserPowerRequireModulation = false;
            bool modEnabled = false;
            float laserPowerMw = 0.0;
            float modWidthus = 0.0;
            float modPeriodus = 0.0;
            float laserPowerPerc = 0.0;
            float lastAppliedLaserPower = 0.0;
            float nextAppliedLaserPower = 0.0;
            int detectorTECSetointDegC = ErrorCodes::InvalidTemperature;
            bool srm_in_EEPROM = false;
 
            // opcodes
            bool setIntegrationTimeMS(unsigned long ms);
            bool setLaserEnable(bool flag);
            bool setDetectorGain(float value);
            bool setDetectorGainOdd(float value);
            bool setDetectorOffset(int16_t value);
            bool setDetectorOffsetOdd(int16_t value);
            bool setDetectorTECEnable(bool flag);
            bool setDetectorTECSetpointDegC(int value);
            bool setHighGainModeEnable(bool flag);
            bool setLaserPowerPerc(float percent);
            std::string getFirmwareVersion();
            std::string getFPGAVersion();
            int32_t getDetectorTemperatureRaw(); 
            float getDetectorTemperatureDegC();
            unsigned long getIntegrationTimeMS();
            bool getLaserEnable();
            float getDetectorGain();
            float getDetectorGainOdd();
            int getDetectorOffset();
            int getDetectorOffsetOdd();
            bool getDetectorTECEnable();
            int getDetectorTECSetpointDegC();
            bool getHighGainModeEnable();
 
            // public to support wp_send/read_control_msg()
            int sendCmd(uint8_t bRequest, uint16_t wValue = 0, uint16_t wIndex = 0, uint8_t* data = NULL, int len = 0);
            bool setModEnable(bool flag);
            bool setModPeriodus(int us);
            bool setModWidthus(int us);
            int getModEnabled(void);
            uint64_t getModPeriodus(void);
            bool setLaserPowermW(float mW_in);
            std::vector<uint8_t> getCmd(uint8_t bRequest, int len, uint16_t wIndex=0, int fullLen=0);
 
            // acquisition
            std::vector<double> getSpectrum();
            bool cancelOperation(bool blocking);
 
        // Private attributes
        private:
            WPVCPP_UDEV_TYPE* udev = nullptr;
 
            std::vector<uint8_t> endpoints;
            std::vector<uint8_t> bufSubspectrum; 
            int pixelsPerEndpoint = 0;
 
            bool detectorTECSetpointHasBeenSet = false;
            bool acquiring = false;
            bool operationCancelled = false;
            int cancelledIntegrationTimeMS = 0;
            bool lastAcquisitionWasCancelled = false;
 
            std::mutex mutAcquisition;
            std::mutex mutComm;
 
            Logger& logger;
 
        // Private methods
        private:
            // initialization
            bool readEEPROM();
 
            // acquisition 
            std::vector<uint16_t> getSubspectrum(uint8_t ep, long allocatedMS);
            long generateTotalWaitMS();
 
            // control messages
            int sendCmd(uint8_t bRequest, uint16_t wValue, uint16_t wIndex, std::vector<uint8_t> data);
            std::vector<uint8_t> getCmd2(uint16_t wValue, int len, uint16_t wIndex=0, int fullLen=0);
            std::vector<uint8_t> getCmdReal(uint8_t bRequest, uint16_t wValue, uint16_t wIndex, int len, int fullLen);
 
            // utility
            bool isSuccess(unsigned char opcode, int result);
            uint16_t serializeGain(float value);
            float deserializeGain(const std::vector<uint8_t>& data);
            inline unsigned long clamp(unsigned long value, unsigned long min, unsigned long max);
            bool lockComm();
            void unlockComm();
    };
}