akela_vna_dll.h

#ifndef __AKELA_VNA_DLL_H
#define __AKELA_VNA_DLL_H

// VNADLL_EXPORTS should only be defined when building the DLL.
// Do not define it when linking to this DLL
#ifdef WIN32
    #ifdef VNADLL_EXPORTS
        #pragma message ("Building with dllexport")
        #define VNADLL_API __declspec(dllexport)
    #else
        #pragma message ("Building with dllimport")
        #define VNADLL_API __declspec(dllimport)
    #endif
#endif
#ifdef LINUX
    #ifdef VNADLL_EXPORTS
        #define __attribute__((visibility("default")))
    #else
        #define VNADLL_API
    #endif
#endif


extern "C" {

    typedef struct task_t* TaskHandle;

    typedef int ErrCode;
    extern VNADLL_API int ERR_OK;
    extern VNADLL_API int ERR_BAD_ATTEN;
    extern VNADLL_API int ERR_BAD_CAL;
    extern VNADLL_API int ERR_BAD_HANDLE;
    extern VNADLL_API int ERR_BAD_HOP;
    extern VNADLL_API int ERR_BAD_PATH;
    extern VNADLL_API int ERR_BAD_PROM;
    extern VNADLL_API int ERR_BYTES;
    extern VNADLL_API int ERR_FREQ_OUT_OF_BOUNDS;
    extern VNADLL_API int ERR_INTERRUPTED;
    extern VNADLL_API int ERR_NO_RESPONSE;
    extern VNADLL_API int ERR_MISSING_IP;
    extern VNADLL_API int ERR_MISSING_PORT;
    extern VNADLL_API int ERR_MISSING_HOP;
    extern VNADLL_API int ERR_MISSING_ATTEN;
    extern VNADLL_API int ERR_MISSING_FREQS;
    extern VNADLL_API int ERR_PROG_OVERFLOW;
    extern VNADLL_API int ERR_SOCKET;
    extern VNADLL_API int ERR_TOO_MANY_POINTS;
    extern VNADLL_API int ERR_WRONG_STATE;
    extern VNADLL_API int ERR_EMPTY_PROM;
    extern VNADLL_API int ERR_PATH_ALREADY_MEASURED;
    extern VNADLL_API int ERR_NO_PATHS_MEASURED;
    extern VNADLL_API int ERR_NO_ATTEN_PRESENT;
    extern VNADLL_API int ERR_PROG_TYPE;


    extern VNADLL_API ErrCode ERR_BAD_PROM;
    extern VNADLL_API ErrCode ERR_BYTES;
    typedef int HopRate;

    extern VNADLL_API HopRate HOP_UNDEFINED;  
    // extern VNADLL_API HopRate HOP_90K;  // This rate is currently unsupported but may be enabled in the future
    extern VNADLL_API HopRate HOP_45K;  
    extern VNADLL_API HopRate HOP_30K;  
    extern VNADLL_API HopRate HOP_15K;  
    extern VNADLL_API HopRate HOP_7K;   
    extern VNADLL_API HopRate HOP_3K;   
    extern VNADLL_API HopRate HOP_2K;   
    extern VNADLL_API HopRate HOP_1K;   
    extern VNADLL_API HopRate HOP_550;  
    extern VNADLL_API HopRate HOP_312;  
    extern VNADLL_API HopRate HOP_156;  
    extern VNADLL_API HopRate HOP_78;   
    extern VNADLL_API HopRate HOP_39;   
    extern VNADLL_API HopRate HOP_20;   

    typedef int Attenuation;
    extern VNADLL_API Attenuation ATTEN_UNDEFINED;  
    extern VNADLL_API Attenuation ATTEN_0;  
    extern VNADLL_API Attenuation ATTEN_1;  
    extern VNADLL_API Attenuation ATTEN_2;  
    extern VNADLL_API Attenuation ATTEN_3;  
    extern VNADLL_API Attenuation ATTEN_4;  
    extern VNADLL_API Attenuation ATTEN_5;  
    extern VNADLL_API Attenuation ATTEN_6;  
    extern VNADLL_API Attenuation ATTEN_7;  
    extern VNADLL_API Attenuation ATTEN_8;  
    extern VNADLL_API Attenuation ATTEN_9;  
    extern VNADLL_API Attenuation ATTEN_10; 
    extern VNADLL_API Attenuation ATTEN_11; 
    extern VNADLL_API Attenuation ATTEN_12; 
    extern VNADLL_API Attenuation ATTEN_13; 
    extern VNADLL_API Attenuation ATTEN_14; 
    extern VNADLL_API Attenuation ATTEN_15; 
    extern VNADLL_API Attenuation ATTEN_16; 
    extern VNADLL_API Attenuation ATTEN_17; 
    extern VNADLL_API Attenuation ATTEN_18; 
    extern VNADLL_API Attenuation ATTEN_19; 
    extern VNADLL_API Attenuation ATTEN_20; 
    extern VNADLL_API Attenuation ATTEN_21; 
    extern VNADLL_API Attenuation ATTEN_22; 
    extern VNADLL_API Attenuation ATTEN_23; 
    extern VNADLL_API Attenuation ATTEN_24; 
    extern VNADLL_API Attenuation ATTEN_25; 
    extern VNADLL_API Attenuation ATTEN_26; 
    extern VNADLL_API Attenuation ATTEN_27; 
    extern VNADLL_API Attenuation ATTEN_28; 
    extern VNADLL_API Attenuation ATTEN_29; 
    extern VNADLL_API Attenuation ATTEN_30; 
    extern VNADLL_API Attenuation ATTEN_31; 

    typedef int TaskState;
    extern VNADLL_API TaskState TASK_UNINITIALIZED; 
    extern VNADLL_API TaskState TASK_STOPPED;       
    extern VNADLL_API TaskState TASK_STARTED;       

    typedef int CalibrationStep;
    extern VNADLL_API CalibrationStep STEP_P1_OPEN;  
    extern VNADLL_API CalibrationStep STEP_P1_SHORT; 
    extern VNADLL_API CalibrationStep STEP_P1_LOAD;  
    extern VNADLL_API CalibrationStep STEP_P2_OPEN;  
    extern VNADLL_API CalibrationStep STEP_P2_SHORT; 
    extern VNADLL_API CalibrationStep STEP_P2_LOAD;  
    extern VNADLL_API CalibrationStep STEP_THRU;     

    typedef struct
    {
        int minimum_frequency;
        int maximum_frequency;
        int maximum_points;
        int serial_number;
        int band_boundaries[8];
        int number_of_band_boundaries;
    } HardwareDetails;

    typedef struct
    {
        double* I;
        double* Q;
    } ComplexData;

    typedef bool (*progress_callback)(int progressPercent, void* user); // return false to cancel



    VNADLL_API const char* versionString();

    VNADLL_API TaskHandle createTask();

    //
    VNADLL_API void deleteTask(TaskHandle t);

    VNADLL_API ErrCode initialize(TaskHandle t, progress_callback callback = 0, void* user=0);

    VNADLL_API ErrCode start(TaskHandle t);

    VNADLL_API ErrCode stop(TaskHandle t);


    VNADLL_API ErrCode setIPAddress(TaskHandle t, const char* ipv4);

    VNADLL_API ErrCode setIPPort(TaskHandle t, const int port);

    //
    //
    VNADLL_API ErrCode setTimeout(TaskHandle t, const unsigned int timeout);

    VNADLL_API ErrCode setHopRate(TaskHandle t, const HopRate rate);

    VNADLL_API ErrCode setAttenuation(TaskHandle t, const Attenuation atten);

    VNADLL_API ErrCode setFrequencies(TaskHandle t, const double* freqs, const unsigned int N);

    //
    VNADLL_API TaskState getState(TaskHandle t);

    //
    VNADLL_API unsigned int getTimeout(TaskHandle t);

    VNADLL_API const char* getIPAddress(TaskHandle t);

// Get the port associated with this Task object. If no port has yet been set, this
// function returns 0.
    VNADLL_API int getIPPort(TaskHandle t);

    //
    VNADLL_API HopRate getHopRate(TaskHandle t);

    //
    VNADLL_API Attenuation getAttenuation(TaskHandle t);

    VNADLL_API unsigned int getNumberOfFrequencies(TaskHandle t);

// Get the list of actual frequencies the hardware generates during the sweep. If no
// frequencies have been set, this function returns 0.
    VNADLL_API const double* getFrequencies(TaskHandle t);

    VNADLL_API HardwareDetails getHardwareDetails(TaskHandle t);

    //
// Possible return values:
// the min and max from the HardwareDetails struct returned by getHardwareDetails())
    VNADLL_API ErrCode utilNearestLegalFreq(TaskHandle t, double& freq);

    //
    //
// Possible return values:
    VNADLL_API ErrCode utilFixLinearSweepLimits(TaskHandle t, double& startFreq, double& endFreq, const unsigned int N);

// Possible return values:
    VNADLL_API ErrCode utilPingUnit(TaskHandle t);

    VNADLL_API ErrCode utilGenerateLinearSweep(TaskHandle t, const double startFreq, const double endFreq, const unsigned int N);

    VNADLL_API ErrCode measureUncalibrated(TaskHandle t,
                                           ComplexData T1R1, ComplexData T1R2,
                                           ComplexData T2R1, ComplexData T2R2,
                                           ComplexData Ref);

    VNADLL_API ErrCode measure2PortCalibrated(TaskHandle t,
            ComplexData S11, ComplexData S21,
            ComplexData S12, ComplexData S22);

    VNADLL_API ErrCode measureCalibrationStep(TaskHandle t, CalibrationStep step);

// These functions let you know the status of the internal raw data arrays
// for each calibration step
    VNADLL_API bool haveCalP1Open(TaskHandle t);
    VNADLL_API bool haveCalP1Short(TaskHandle t);
    VNADLL_API bool haveCalP1Load(TaskHandle t);
    VNADLL_API bool haveCalP2Open(TaskHandle t);
    VNADLL_API bool haveCalP2Short(TaskHandle t);
    VNADLL_API bool haveCalP2Load(TaskHandle t);
    VNADLL_API bool haveCalThru(TaskHandle t);

    VNADLL_API ErrCode interruptMeasurement(TaskHandle t);

    VNADLL_API ErrCode clearCalibration(TaskHandle t);

    VNADLL_API bool isCalibrationComplete(TaskHandle t);

// Get the number of frequencies in the calibration data
    VNADLL_API unsigned int getCalibrationNumberOfFrequencies(TaskHandle t);

    VNADLL_API const double* getCalibrationFrequencies(TaskHandle t);

    //
    //

    VNADLL_API ErrCode exportCalibration(TaskHandle t,
                                         ComplexData e00,       /* EDF */
                                         ComplexData e11,       /* ESF */
                                         ComplexData e10e01,        /* ERF */
                                         ComplexData e30,       /* EXF */
                                         ComplexData e22,       /* ELF */
                                         ComplexData e10e32,        /* ETF */
                                         ComplexData ep33,      /* EDR */
                                         ComplexData ep22,      /* ESR */
                                         ComplexData ep23ep32,  /* ERR */
                                         ComplexData ep03,      /* EXR */
                                         ComplexData ep11,      /* ELR */
                                         ComplexData ep23ep01   /* ETR */);

    VNADLL_API ErrCode importCalibration(TaskHandle t,
                                         const double* freqs,
                                         const unsigned int N,
                                         const ComplexData e00,     /* EDF */
                                         const ComplexData e11,     /* ESF */
                                         const ComplexData e10e01,  /* ERF */
                                         const ComplexData e30,     /* EXF */
                                         const ComplexData e22,     /* ELF */
                                         const ComplexData e10e32,  /* ETF */
                                         const ComplexData ep33,        /* EDR */
                                         const ComplexData ep22,        /* ESR */
                                         const ComplexData ep23ep32,    /* ERR */
                                         const ComplexData ep03,        /* EXR */
                                         const ComplexData ep11,        /* ELR */
                                         const ComplexData ep23ep01 /* ETR */);

    VNADLL_API bool hasFactoryCalibration(TaskHandle t);

    VNADLL_API ErrCode importFactoryCalibration(TaskHandle t);

    //VNADLL_API ErrCode setOpenPhaseCorrection(TaskHandle t, const double* const phaseCorrections);




}




#endif