SeaBreezeAPI.h

Go to the documentation of this file.

/***************************************************/
#ifndef SEABREEZEAPI_H
#define SEABREEZEAPI_H

#include "api/DllDecl.h"

#ifdef __cplusplus

#include "api/seabreezeapi/DeviceAdapter.h"

class DLL_DECL SeaBreezeAPI {
public:
    static SeaBreezeAPI *getInstance();

    static void shutdown();

    int probeDevices();
    
    int addTCPIPv4DeviceLocation(char *deviceTypeName, char *ipAddr, int port);

    int addRS232DeviceLocation(char *deviceTypeName, char *deviceBusPath, unsigned int baud);

    int getNumberOfDeviceIDs();

    int getDeviceIDs(long *ids, unsigned long maxLength);

    int openDevice(long id, int *errorCode);

    void closeDevice(long id, int *errorCode);

    /* Get a string that describes the type of device */
    int getDeviceType(long id, int *errorCode, char *buffer, unsigned int length);
    
    /* Get the usb endpoint address for a specified type of endpoint */
    unsigned char getDeviceEndpoint(long id, int *error_code, usbEndpointType endpointType);

    /* Get raw usb access capabilities */
    int getNumberOfRawUSBBusAccessFeatures(long deviceID, int *errorCode);
    int getRawUSBBusAccessFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int rawUSBBusAccessRead(long deviceID, long featureID, int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char endpoint);
    int rawUSBBusAccessWrite(long deviceID, long featureID, int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char endpoint);
    
    /* Serial number capabilities */
    int getNumberOfSerialNumberFeatures(long deviceID, int *errorCode);
    int getSerialNumberFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int getSerialNumber(long deviceID, long featureID, int *errorCode, char *buffer, int bufferLength);
    unsigned char getSerialNumberMaximumLength(long deviceID, long featureID, int *errorCode);

    /* Spectrometer capabilities */
    int getNumberOfSpectrometerFeatures(long id, int *errorCode);
    int getSpectrometerFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void spectrometerSetTriggerMode(long deviceID, long spectrometerFeatureID, int *errorCode, int mode);
    void spectrometerSetIntegrationTimeMicros(long deviceID, long spectrometerFeatureID, int *errorCode, unsigned long integrationTimeMicros);
    unsigned long spectrometerGetMinimumIntegrationTimeMicros(long deviceID, long spectrometerFeatureID, int *errorCode);
    unsigned long spectrometerGetMaximumIntegrationTimeMicros(long deviceID, long spectrometerFeatureID, int *errorCode);
    double spectrometerGetMaximumIntensity(long deviceID, long spectrometerFeatureID, int *errorCode);
    int spectrometerGetUnformattedSpectrumLength(long deviceID, long spectrometerFeatureID, int *errorCode);
    int spectrometerGetUnformattedSpectrum(long deviceID, long spectrometerFeatureID, int *errorCode, unsigned char *buffer, int bufferLength);
    int spectrometerGetFormattedSpectrumLength(long deviceID, long spectrometerFeatureID, int *errorCode);
    int spectrometerGetFormattedSpectrum(long deviceID, long spectrometerFeatureID, int *errorCode, double *buffer, int bufferLength);
    int spectrometerGetWavelengths(long deviceID, long spectrometerFeatureID, int *errorCode, double *wavelengths, int length);
    int spectrometerGetElectricDarkPixelCount(long deviceID, long spectrometerFeatureID, int *errorCode);
    int spectrometerGetElectricDarkPixelIndices(long deviceID, long spectrometerFeatureID, int *errorCode, int *indices, int length);

    /* Pixel binning capabilities */
    int getNumberOfPixelBinningFeatures(long id, int *errorCode);
    int getPixelBinningFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void binningSetPixelBinningFactor(long deviceID, long spectrometerFeatureID, int *errorCode, const unsigned char binningFactor);
    unsigned char binningGetPixelBinningFactor(long deviceID, long spectrometerFeatureID, int *errorCode);
    void binningSetDefaultPixelBinningFactor(long deviceID, long spectrometerFeatureID, int *errorCode, const unsigned char binningFactor);
    void binningSetDefaultPixelBinningFactor(long deviceID, long spectrometerFeatureID, int *errorCode);
    unsigned char binningGetDefaultPixelBinningFactor(long deviceID, long spectrometerFeatureID, int *errorCode);
    unsigned char binningGetMaxPixelBinningFactor(long deviceID, long spectrometerFeatureID, int *errorCode);
        
    /* TEC capabilities */
    int getNumberOfThermoElectricFeatures(long deviceID, int *errorCode);
    int getThermoElectricFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    double tecReadTemperatureDegreesC(long deviceID, long featureID, int *errorCode);
    void tecSetTemperatureSetpointDegreesC(long deviceID, long featureID, int *errorCode, double temperatureDegreesCelsius);
    void tecSetEnable(long deviceID, long featureID, int *errorCode, unsigned char tecEnable);

    /* Irradiance calibration features */
    int getNumberOfIrradCalFeatures(long deviceID, int *errorCode);
    int getIrradCalFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int irradCalibrationRead(long deviceID, long featureID, int *errorCode, float *buffer, int bufferLength);
    int irradCalibrationWrite(long deviceID, long featureID, int *errorCode, float *buffer, int bufferLength);
    int irradCalibrationHasCollectionArea(long deviceID, long featureID, int *errorCode);
    float irradCalibrationReadCollectionArea(long deviceID, long featureID, int *errorCode);
    void irradCalibrationWriteCollectionArea(long deviceID, long featureID, int *errorCode, float area);

    /* EEPROM capabilities */
    int getNumberOfEEPROMFeatures(long deviceID, int *errorCode);
    int getEEPROMFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int eepromReadSlot(long deviceID, long featureID, int *errorCode, int slotNumber, unsigned char *buffer, int bufferLength);

    /* Light source capabilities */
    int getNumberOfLightSourceFeatures(long deviceID, int *errorCode);
    int getLightSourceFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int lightSourceGetCount(long deviceID, long featureID, int *errorCode);
    bool lightSourceHasEnable(long deviceID, long featureID, int *errorCode, int lightSourceIndex);
    bool lightSourceIsEnabled(long deviceID, long featureID, int *errorCode, int lightSourceIndex);
    void lightSourceSetEnable(long deviceID, long featureID, int *errorCode, int lightSourceIndex, bool enable);
    bool lightSourceHasVariableIntensity(long deviceID, long featureID, int *errorCode, int lightSourceIndex);
    double lightSourceGetIntensity(long deviceID, long featureID, int *errorCode, int lightSourceIndex);
    void lightSourceSetIntensity(long deviceID, long featureID, int *errorCode, int lightSourceIndex, double intensity);

    /* Lamp capabilities */
    int getNumberOfLampFeatures(long deviceID, int *errorCode);
    int getLampFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void lampSetLampEnable(long deviceID, long featureID, int *errorCode, bool strobeEnable);

    /* Continuous strobe capabilities */
    int getNumberOfContinuousStrobeFeatures(long deviceID, int *errorCode);
    int getContinuousStrobeFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void continuousStrobeSetContinuousStrobeEnable(long deviceID, long featureID, int *errorCode, bool strobeEnable);
    void continuousStrobeSetContinuousStrobePeriodMicroseconds(long deviceID, long featureID, int *errorCode, unsigned long strobePeriodMicroseconds);

    /* Shutter capabilities */
    int getNumberOfShutterFeatures(long deviceID, int *errorCode);
    int getShutterFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void shutterSetShutterOpen(long deviceID, long featureID, int *errorCode, bool opened);

    /* Nonlinearity coefficient capabilities */
    int getNumberOfNonlinearityCoeffsFeatures(long deviceID, int *errorCode);
    int getNonlinearityCoeffsFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int nonlinearityCoeffsGet(long deviceID, long featureID, int *errorCode, double *buffer, int maxLength);

    /* Temperature capabilities */
    int getNumberOfTemperatureFeatures(long deviceID, int *errorCode);
    int getTemperatureFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    unsigned char temperatureCountGet(long deviceID, long featureID, int *errorCode);
    double temperatureGet(long deviceID, long featureID, int *errorCode, int index);
    int temperatureGetAll(long deviceID, long featureID, int *errorCode, double *buffer, int maxLength);

    /* Spectrum processing capabilities */
    int getNumberOfSpectrumProcessingFeatures(long deviceID, int *errorCode);
    int getSpectrumProcessingFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    unsigned char spectrumProcessingBoxcarWidthGet(long deviceID, long featureID, int *errorCode);
    unsigned short int spectrumProcessingScansToAverageGet(long deviceID, long featureID, int *errorCode);
    void spectrumProcessingBoxcarWidthSet(long deviceID, long featureID, int *errorCode, unsigned char boxcarWidth);
    void spectrumProcessingScansToAverageSet(long deviceID, long featureID, int *errorCode, unsigned short int scansToAverage);
 
    /* Revision capabilities */
    int getNumberOfRevisionFeatures(long deviceID, int *errorCode);
    int getRevisionFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    unsigned char revisionHardwareGet(long deviceID, long featureID, int *errorCode);
    unsigned short int revisionFirmwareGet(long deviceID, long featureID, int *errorCode);

    /* Optical Bench capabilities */
    int getNumberOfOpticalBenchFeatures(long deviceID, int *errorCode);
    int getOpticalBenchFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    unsigned short int opticalBenchGetFiberDiameterMicrons(long deviceID, long featureID, int *errorCode);
    unsigned short int opticalBenchGetSlitWidthMicrons(long deviceID, long featureID, int *errorCode);
    int opticalBenchGetID(long deviceID, long featureID, int *errorCode, char *buffer, int bufferLength);
    int opticalBenchGetSerialNumber(long deviceID, long featureID, int *errorCode, char *buffer, int bufferLength);
    int opticalBenchGetCoating(long deviceID, long featureID, int *errorCode, char *buffer, int bufferLength);
    int opticalBenchGetFilter(long deviceID, long featureID, int *errorCode, char *buffer, int bufferLength);
    int opticalBenchGetGrating(long deviceID, long featureID, int *errorCode, char *buffer, int bufferLength);

    /* Stray light coefficient capabilities */
    int getNumberOfStrayLightCoeffsFeatures(long deviceID, int *errorCode);
    int getStrayLightCoeffsFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    int strayLightCoeffsGet(long deviceID, long featureID, int *errorCode, double *buffer, int maxLength);

    /* Data buffer capabilities */
    int getNumberOfDataBufferFeatures(long deviceID, int *errorCode);
    int getDataBufferFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void dataBufferClear(long deviceID, long featureID, int *errorCode);
    unsigned long dataBufferGetNumberOfElements(long deviceID, long featureID, int *errorCode);
    unsigned long dataBufferGetBufferCapacity(long deviceID, long featureID, int *errorCode);
    unsigned long dataBufferGetBufferCapacityMaximum(long deviceID, long featureID, int *errorCode);
    unsigned long dataBufferGetBufferCapacityMinimum(long deviceID, long featureID, int *errorCode);
    void dataBufferSetBufferCapacity(long deviceID, long featureID, int *errorCode, unsigned long capacity);

    /* Acquisition delay capabilities */
    int getNumberOfAcquisitionDelayFeatures(long deviceID, int *errorCode);
    int getAcquisitionDelayFeatures(long deviceID, int *errorCode, long *buffer, unsigned int maxLength);
    void acquisitionDelaySetDelayMicroseconds(long deviceID, long featureID,
            int *errorCode, unsigned long delay_usec);
    unsigned long acquisitionDelayGetDelayMicroseconds(long deviceID,
            long featureID, int *errorCode);
    unsigned long acquisitionDelayGetDelayIncrementMicroseconds(long deviceID,
            long featureID, int *errorCode);
    unsigned long acquisitionDelayGetDelayMaximumMicroseconds(long deviceID,
            long featureID, int *errorCode);
    unsigned long acquisitionDelayGetDelayMinimumMicroseconds(long deviceID,
            long featureID, int *errorCode);

private:
    SeaBreezeAPI();
    virtual ~SeaBreezeAPI();

    seabreeze::api::DeviceAdapter *getDeviceByID(unsigned long id);

    static SeaBreezeAPI *instance;

    std::vector<seabreeze::api::DeviceAdapter *> probedDevices;
    std::vector<seabreeze::api::DeviceAdapter *> specifiedDevices;
};

extern "C" {
#endif /* __cplusplus */

    /* All of these C functions start with sbapi_ to prevent namespace
     * collisions.
     */

    DLL_DECL void sbapi_initialize();

    DLL_DECL void sbapi_shutdown();
    
    DLL_DECL int
    sbapi_add_TCPIPv4_device_location(char *deviceTypeName, char *ipAddress,
                unsigned int port);

    DLL_DECL int
    sbapi_add_RS232_device_location(char *deviceTypeName, char *deviceBusPath,
                unsigned int baud);

    DLL_DECL int
    sbapi_probe_devices();

    DLL_DECL int
    sbapi_get_number_of_device_ids();

    DLL_DECL int
    sbapi_get_device_ids(long *ids, unsigned int max_ids);

    DLL_DECL int
    sbapi_open_device(long id, int *error_code);

    DLL_DECL void
    sbapi_close_device(long id, int *error_code);

    DLL_DECL const char *
    sbapi_get_error_string(int error_code);

    DLL_DECL int
    sbapi_get_device_type(long id, int *error_code,
            char *buffer, unsigned int length);

    DLL_DECL unsigned char
    sbapi_get_device_usb_endpoint_primary_out(long id, int *error_code);

    DLL_DECL unsigned char
    sbapi_get_device_usb_endpoint_primary_in(long id, int *error_code);
    
    DLL_DECL unsigned char
    sbapi_get_device_usb_endpoint_secondary_out(long id, int *error_code);

    DLL_DECL unsigned char
    sbapi_get_device_usb_endpoint_secondary_in(long id, int *error_code);

    DLL_DECL unsigned char
    sbapi_get_device_usb_endpoint_secondary_in2(long id, int *error_code);


    DLL_DECL int
    sbapi_get_number_of_raw_usb_bus_access_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_raw_usb_bus_access_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL int
    sbapi_raw_usb_bus_access_read(long deviceID, long featureID,
            int *error_code, unsigned char *buffer, int buffer_length, unsigned char endpoint);

    DLL_DECL int
    sbapi_raw_usb_bus_access_write(long deviceID, long featureID,
            int *error_code, unsigned char *buffer, int buffer_length, unsigned char endpoint);


    DLL_DECL int
    sbapi_get_number_of_serial_number_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_serial_number_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL int
    sbapi_get_serial_number(long deviceID, long featureID, int *error_code,
            char *buffer, int buffer_length);

    DLL_DECL unsigned char
    sbapi_get_serial_number_maximum_length(long deviceID, long featureID, int *error_code);
            
    DLL_DECL int
    sbapi_get_number_of_spectrometer_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_spectrometer_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL void
    sbapi_spectrometer_set_trigger_mode(long deviceID, long featureID,
        int *error_code, int mode);

    DLL_DECL void
    sbapi_spectrometer_set_integration_time_micros(long deviceID, long featureID,
            int *error_code, unsigned long integration_time_micros);

    DLL_DECL long
    sbapi_spectrometer_get_minimum_integration_time_micros(long deviceID,
            long featureID, int *error_code);

    DLL_DECL double
    sbapi_spectrometer_get_maximum_intensity(long deviceID,
            long featureID, int *error_code);

    DLL_DECL int
    sbapi_spectrometer_get_formatted_spectrum_length(long deviceID,
            long featureID, int *error_code);

    DLL_DECL int
    sbapi_spectrometer_get_formatted_spectrum(long deviceID,
            long featureID, int *error_code,
            double* buffer, int buffer_length);

    DLL_DECL int
    sbapi_spectrometer_get_unformatted_spectrum_length(long deviceID,
            long featureID, int *error_code);

    DLL_DECL int
    sbapi_spectrometer_get_unformatted_spectrum(long deviceID,
            long featureID, int *error_code,
            unsigned char *buffer, int buffer_length);

    DLL_DECL int
    sbapi_spectrometer_get_wavelengths(long deviceID,
            long featureID, int *error_code, double *wavelengths, int length);

    DLL_DECL int
    sbapi_spectrometer_get_electric_dark_pixel_count(long deviceID,
            long featureID, int *error_code);

    DLL_DECL int
    sbapi_spectrometer_get_electric_dark_pixel_indices(long deviceID,
            long featureID, int *error_code, int *indices, int length);

    DLL_DECL int
    sbapi_get_number_of_pixel_binning_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_pixel_binning_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL void
    sbapi_binning_set_pixel_binning_factor(long deviceID, long featureID,
            int *error_code, unsigned char factor);

    DLL_DECL unsigned char
    sbapi_binning_get_pixel_binning_factor(long deviceID, long featureID, int *error_code);

    DLL_DECL void
    sbapi_binning_set_default_pixel_binning_factor(long deviceID, long featureID,
            int *error_code, unsigned char factor);

    DLL_DECL void
    sbapi_binning_reset_default_pixel_binning_factor(long deviceID, long featureID,
            int *error_code);

    DLL_DECL unsigned char
    sbapi_binning_get_default_pixel_binning_factor(long deviceID, long featureID, int *error_code);

    DLL_DECL unsigned char
    sbapi_binning_get_max_pixel_binning_factor(long deviceID, long featureID, int *error_code);

    DLL_DECL int
    sbapi_get_number_of_shutter_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_shutter_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL void
    sbapi_shutter_set_shutter_open(long deviceID, long featureID,
            int *error_code, unsigned char opened);

    DLL_DECL int
    sbapi_get_number_of_light_source_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_light_source_features(long deviceID, int *error_code,
            long *features, int max_features);

    DLL_DECL int
    sbapi_light_source_get_count(long deviceID, long featureID, int *error_code);

    DLL_DECL unsigned char
    sbapi_light_source_has_enable(long deviceID, long featureID, int *error_code,
            int light_source_index);

    DLL_DECL unsigned char
    sbapi_light_source_is_enabled(long deviceID, long featureID, int *error_code,
            int light_source_index);

    DLL_DECL void
    sbapi_light_source_set_enable(long deviceID, long featureID, int *error_code,
            int light_source_index, unsigned char enable);

    DLL_DECL unsigned char
    sbapi_light_source_has_variable_intensity(long deviceID, long featureID,
        int *error_code, int light_source_index);

    DLL_DECL double
    sbapi_light_source_get_intensity(long deviceID, long featureID,
        int *error_code, int light_source_index);

    DLL_DECL void
    sbapi_light_source_set_intensity(long deviceID, long featureID,
        int *error_code, int light_source_index, double intensity);

    /*
     * This function returns the total number of strobe/lamp instances available
     * in the indicated device.
     *
     * @param deviceID (Input) The index of a device previously opened with sbapi_open_device().
     * @param error_code (Output) A pointer to an integer that can be used for storing
     *      error codes.
     *
     * @return the number of strobe/lamp features that will be returned
     *      by a call to sbapi_get_strobe_lamp_features().
     */
     
// There is not code in seabreezeAPI.cpp for this function. Perhaps it was not finished
     
    //DLL_DECL int
    //sbapi_get_number_of_strobe_lamp_features(long deviceID, int *error_code);

    /*
     * This function returns IDs for accessing each strobe/lamp instance for this
     * device.  The IDs are only valid when used with the deviceID used to
     * obtain them.
     *
     * @param deviceID (Input) The index of a device previously opened with sbapi_open_device().
     * @param error_code (Output) A pointer to an integer that can be used for storing
     *      error codes.
     * @param features (Output) a preallocated array to hold returned feature handles
     * @param max_features (Input) length of the preallocated buffer
     *
     * @return the number of strobe/lamp feature IDs that were copied.
     */
     
// There is not code in seabreezeAPI.cpp for this function. Perhaps it was not finished.
    
    //DLL_DECL int
    //sbapi_get_strobe_lamp_features(long deviceID, int *error_code, long *features,
    //        int max_features);

    DLL_DECL int
    sbapi_get_number_of_lamp_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_lamp_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL void
    sbapi_lamp_set_lamp_enable(long deviceID, long featureID,
            int *error_code, unsigned char lamp_enable);

    DLL_DECL int
    sbapi_get_number_of_continuous_strobe_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_continuous_strobe_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL void
    sbapi_continuous_strobe_set_continuous_strobe_enable(long deviceID, long featureID,
            int *error_code, unsigned char enable);

    DLL_DECL void
    sbapi_continuous_strobe_set_continuous_strobe_period_micros(long deviceID, long featureID,
            int *error_code, unsigned long period_micros);

    DLL_DECL int
    sbapi_get_number_of_eeprom_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_eeprom_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL int
    sbapi_eeprom_read_slot(long deviceID, long featureID,
            int *error_code, int slot_number,
            unsigned char *buffer, int buffer_length);

    DLL_DECL int
    sbapi_get_number_of_irrad_cal_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_irrad_cal_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL int
    sbapi_irrad_calibration_read(long deviceID, long featureID,
            int *error_code, float *buffer, int buffer_length);

    DLL_DECL int
    sbapi_irrad_calibration_write(long deviceID, long featureID,
            int *error_code, float *buffer, int buffer_length);

    DLL_DECL int
    sbapi_irrad_calibration_has_collection_area(long deviceID, long featureID,
            int *error_code);

    DLL_DECL float
    sbapi_irrad_calibration_read_collection_area(long deviceID, long featureID,
            int *error_code);

    DLL_DECL void
    sbapi_irrad_calibration_write_collection_area(long deviceID, long featureID,
            int *error_code, float area);

    DLL_DECL int
    sbapi_get_number_of_thermo_electric_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_thermo_electric_features(long deviceID, int *error_code, long *features,
            int max_features);

    DLL_DECL double
    sbapi_tec_read_temperature_degrees_C(long deviceID, long featureID,
            int *error_code);

    DLL_DECL void
    sbapi_tec_set_temperature_setpoint_degrees_C(long deviceID, long featureID,
            int *error_code, double temperature_degrees_celsius);

    DLL_DECL void
    sbapi_tec_set_enable(long deviceID, long featureID,
            int *error_code, unsigned char tec_enable);

    DLL_DECL int
    sbapi_get_number_of_nonlinearity_coeffs_features(
            long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_nonlinearity_coeffs_features(long deviceID, int *error_code,
            long *features, int max_features);

    DLL_DECL int sbapi_nonlinearity_coeffs_get(long deviceID, long featureID,
            int *error_code, double *buffer, int max_length);

    DLL_DECL int
    sbapi_get_number_of_temperature_features(
            long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_temperature_features(long deviceID, int *error_code,
            long *temperatureFeatures, int max_features);

    DLL_DECL unsigned char sbapi_temperature_count_get(long deviceID, long temperatureFeatureID, int *error_code);

    DLL_DECL double sbapi_temperature_get(long deviceID, long temperatureFeatureID, int *error_code, int index);

    DLL_DECL int sbapi_temperature_get_all(long deviceID, long temperatureFeatureID, int *error_code, double *buffer, int max_length);



    DLL_DECL int
    sbapi_get_number_of_spectrum_processing_features(
            long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_spectrum_processing_features(long deviceID, int *error_code,
            long *spectrumProcessingFeatures, int max_features);

    DLL_DECL unsigned short int sbapi_spectrum_processing_scans_to_average_get(long deviceID,
         long spectrumProcessingFeatureID, int *error_code);

    DLL_DECL void sbapi_spectrum_processing_scans_to_average_set(long deviceID, 
        long spectrumProcessingFeatureID, int *error_code, unsigned short int scansToAverage);

    DLL_DECL unsigned char sbapi_spectrum_processing_boxcar_width_get(long deviceID,
         long spectrumProcessingFeatureID, int *error_code);

    DLL_DECL void sbapi_spectrum_processing_boxcar_width_set(long deviceID, 
            long spectrumProcessingFeatureID, int *error_code, unsigned char boxcarWidth);
   


    DLL_DECL int
    sbapi_get_number_of_revision_features(
            long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_revision_features(long deviceID, int *error_code,
            long *revisionFeatures, int max_features);

    DLL_DECL unsigned char sbapi_revision_hardware_get(long deviceID, long revisionFeatureID, int *error_code);

    DLL_DECL unsigned short int sbapi_revision_firmware_get(long deviceID, long revisionFeatureID, int *error_code);

    DLL_DECL int
    sbapi_get_number_of_optical_bench_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_optical_bench_features(long deviceID, int *error_code, long *opticalBenchFeatures, int max_features);

    DLL_DECL unsigned short int sbapi_optical_bench_get_fiber_diameter_microns(long deviceID, long opticalBenchFeatureID, int *error_code);

    DLL_DECL unsigned short int sbapi_optical_bench_get_slit_width_microns(long deviceID, long opticalBenchFeatureID, int *error_code);

    DLL_DECL int
    sbapi_optical_bench_get_id(long deviceID, long featureID, int *error_code, char *buffer, int buffer_length);
 
    DLL_DECL int
    sbapi_optical_bench_get_serial_number(long deviceID, long featureID, int *error_code, char *buffer, int buffer_length);


    DLL_DECL int
    sbapi_optical_bench_get_coating(long deviceID, long featureID, int *error_code, char *buffer, int buffer_length);
    
    DLL_DECL int
    sbapi_optical_bench_get_filter(long deviceID, long featureID, int *error_code, char *buffer, int buffer_length);
    
    DLL_DECL int
    sbapi_optical_bench_get_grating(long deviceID, long featureID, int *error_code, char *buffer, int buffer_length);
    
                 
    DLL_DECL int
    sbapi_get_number_of_stray_light_coeffs_features(long deviceID, int *error_code);

    DLL_DECL int
    sbapi_get_stray_light_coeffs_features(long deviceID, int *error_code,
            long *features, int max_features);

    DLL_DECL int sbapi_stray_light_coeffs_get(long deviceID, long featureID,
            int *error_code, double *buffer, int max_length);


    DLL_DECL int sbapi_get_number_of_data_buffer_features(long deviceID, int *error_code);

    DLL_DECL int sbapi_get_data_buffer_features(long deviceID, int *error_code,
            long *buffer, unsigned int maxLength);

    DLL_DECL void sbapi_data_buffer_clear(long deviceID, long featureID, int *error_code);

    DLL_DECL unsigned long sbapi_data_buffer_get_number_of_elements(long deviceID,
            long featureID, int *error_code);

    DLL_DECL unsigned long sbapi_data_buffer_get_buffer_capacity(long deviceID,
            long featureID, int *error_code);

    DLL_DECL unsigned long sbapi_data_buffer_get_buffer_capacity_maximum(
            long deviceID, long featureID, int *error_code);

    DLL_DECL unsigned long sbapi_data_buffer_get_buffer_capacity_minimum(
            long deviceID, long featureID, int *error_code);

    DLL_DECL void sbapi_data_buffer_set_buffer_capacity(long deviceID,
            long featureID, int *error_code, unsigned long capacity);

    DLL_DECL int sbapi_get_number_of_acquisition_delay_features(long deviceID, int *errorCode);

    DLL_DECL int sbapi_get_acquisition_delay_features(long deviceID, int *errorCode,
            long *buffer, unsigned int maxLength);

    DLL_DECL void sbapi_acquisition_delay_set_delay_microseconds(long deviceID, long featureID,
            int *errorCode, unsigned long delay_usec);

    DLL_DECL unsigned long sbapi_acquisition_delay_get_delay_microseconds(long deviceID,
            long featureID, int *errorCode);

    DLL_DECL unsigned long sbapi_acquisition_delay_get_delay_increment_microseconds(long deviceID,
            long featureID, int *errorCode);

    DLL_DECL unsigned long sbapi_acquisition_delay_get_delay_maximum_microseconds(long deviceID,
            long featureID, int *errorCode);

    DLL_DECL unsigned long sbapi_acquisition_delay_get_delay_minimum_microseconds(long deviceID,
            long featureID, int *errorCode);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* SEABREEZEAPI_H */