PwrSnsrLib.h

Go to the documentation of this file.

 /******************************************************************************
  *
  * Copyright 2014-19 WTG. All rights reserved.
  *
  *****************************************************************************/

  /*
   * File:   PwrSnsrLib.h
   * Author: WTG
   *
   * Created on September 19, 2014, 3:32 PM
   * 4/3/2017 Updated to match current functionality of the Windows API.
   * 4/25/2017 Updated function descriptions.
   * 9/5/2018 Bug fix for advanced measurement buffer functions.
   * 11/20/2018 Ported to Windows
   * 5/10/2018 Added simulation channels.
   */

#ifndef PWRSNSRLIB_H
#define PWRSNSRLIB_H

#define SUCCESS          (0L)

#define CURRENT_TIMEOUT (-2)

#ifdef _WIN32

#  define EXPORT __declspec( dllexport )
#else
#  define EXPORT
#endif

typedef int SessionID;

typedef enum PwrSnsrAcquisitionStatusEnum
{
    PwrSnsrAcqComplete = 1, 
    PwrSnsrAcqInProgress = 0, 
    PwrSnsrAcqStatusUnknown = -1 
} PwrSnsrAcquisitionStatusEnum;

typedef enum PwrSnsrTriggerModeEnum
{
    PwrSnsrTriggerModeNormal = 1, 
    PwrSnsrTriggerModeAuto = 2, 
    PwrSnsrTriggerModeAutoLevel = 3, 
    PwrSnsrTriggerModeFreerun = 4 
} PwrSnsrTriggerModeEnum;

typedef enum PwrSnsrTriggerSlopeEnum
{
    PwrSnsrTriggerSlopePositive = 1, 
    PwrSnsrTriggerSlopeNegative = 0
} PwrSnsrTriggerSlopeEnum;

typedef enum PwrSnsrTriggerPositionEnum
{
    PwrSnsrTriggerPositionLeft = 0, 
    PwrSnsrTriggerPositionMiddle = 1, 
    PwrSnsrTriggerPositionRight = 2
} PwrSnsrTriggerPositionEnum;

typedef enum PwrSnsrTriggerSourceEnum
{
    PwrSnsrTriggerSourceChannel1 = 0, 
    PwrSnsrTriggerSourceExternal = 2, 
    PwrSnsrTriggerSourceChannel2 = 1, 
    PwrSnsrTriggerSourceChannel3 = 3, 
    PwrSnsrTriggerSourceChannel4 = 4, 
    PwrSnsrTriggerSourceChannel5 = 5, 
    PwrSnsrTriggerSourceChannel6 = 6, 
    PwrSnsrTriggerSourceChannel7 = 7, 
    PwrSnsrTriggerSourceChannel8 = 8, 
    PwrSnsrTriggerSourceChannel9 = 9, 
    PwrSnsrTriggerSourceChannel10 = 10, 
    PwrSnsrTriggerSourceChannel11 = 11, 
    PwrSnsrTriggerSourceChannel12 = 12, 
    PwrSnsrTriggerSourceChannel13 = 13, 
    PwrSnsrTriggerSourceChannel14 = 14, 
    PwrSnsrTriggerSourceChannel15 = 15, 
    PwrSnsrTriggerSourceChannel16 = 16, 
    PwrSnsrTriggerSourceIndependent = 17
} PwrSnsrTriggerSourceEnum;


typedef enum PwrSnsrUnitsEnum
{
    PwrSnsrUnitsdBm = 0, 
    PwrSnsrUnitswatts = 1, 
    PwrSnsrUnitsvolts = 2, 
    PwrSnsrUnitsDBV = 3, 
    PwrSnsrUnitsDBMV = 4, 
    PwrSnsrUnitsDBUV = 5
} PwrSnsrUnitsEnum;

typedef enum PwrSnsrMarkerNumberEnum
{
    PwrSnsrMarkerNumberMarker1 = 1, 
    PwrSnsrMarkerNumberMarker2 = 2
} PwrSnsrMarkerNumberEnum;

typedef enum PwrSnsrBandwidthEnum
{
    PwrSnsrBandwidthHigh = 0, 
    PwrSnsrBandwidthLow = 1
} PwrSnsrBandwidthEnum;

typedef enum PwrSnsrFilterStateEnum
{
    PwrSnsrFilterStateOff = 0, 
    PwrSnsrFilterStateOn = 1, 
    PwrSnsrFilterStateAuto = 2 
} PwrSnsrFilterStateEnum;

typedef enum PwrSnsrPulseUnitsEnum
{
    PwrSnsrPulseUnitsWatts = 0, 
    PwrSnsrPulseUnitsVolts = 1
} PwrSnsrPulseUnitsEnum;

typedef enum PwrSnsrCondCodeEnum
{
    PwrSnsrCondCodeMeasurementStopped = -1, 
    PwrSnsrCondCodeError = 0, 
    PwrSnsrCondCodeUnderrange = 2, 
    PwrSnsrCondCodeOverrange = 3, 
    PwrSnsrCondCodeNormal = 1
} PwrSnsrCondCodeEnum;

typedef enum PwrSnsrTriggerStatusEnum
{
    PwrSnsrTriggerStatusStopped = 0, 
    PwrSnsrTriggerStatusPretrig = 1, 
    PwrSnsrTriggerStatusWaiting = 2, 
    PwrSnsrTriggerStatusAcquiringNew = 3, 
    PwrSnsrTriggerStatusAutoTrig = 4, 
    PwrSnsrTriggerStatusFreerun = 5, 
    PwrSnsrTriggerStatusTriggered = 6, 
    PwrSnsrTriggerStatusRunning = 7
} PwrSnsrTriggerStatusEnum;

typedef enum PwrSnsrTermActionEnum
{
    PwrSnsrTermActionStop = 0, 
    PwrSnsrTermActionRestart = 1, 
    PwrSnsrTermActionDecimate = 2
} PwrSnsrTermActionEnum;

typedef enum PwrSnsrHoldoffModeEnum
{
    PwrSnsrHoldoffModeNormal = 1, 
    PwrSnsrHoldoffModeGap = 2
} PwrSnsrHoldoffModeEnum;

typedef enum PwrSnsrStatGatingEnum
{
    PwrSnsrStatGatingFreeRun = 0, 
    PwrSnsrStatGatingMarkers = 1
} PwrSnsrStatGatingEnum;

typedef enum PwrSnsrTrigOutModeEnum
{
    PwrSnsrTrigOutModeMioOff = 0,
    PwrSnsrTrigOutModeMioPullUp = 1,
    PwrSnsrTrigOutModeMioTtl0 = 2,
    PwrSnsrTrigOutModeMioTbRef = 3,
    PwrSnsrTrigOutModeMioSweepHigh = 4,
    PwrSnsrTrigOutModeMioSweepLow = 5,
    PwrSnsrTrigOutModeMioTrigHigh = 6,
    PwrSnsrTrigOutModeMioTrigLow = 7,
    PwrSnsrTrigOutModeMioMaster = 8,
    PwrSnsrTrigOutModeMioSlave = 9
} PwrSnsrTrigOutModeEnum;

typedef enum PwrSnsrMeasBuffGateEnum
{
    PwrSnsrMeasBuffGateBurst = 0,
    PwrSnsrMeasBuffGateMarker = 1,
    PwrSnsrMeasBuffGateExtGate = 2,
    PwrSnsrMeasBuffGatePeriodic = 3,
    PwrSnsrMeasBuffGateExtTrig = 4
} PwrSnsrMeasBuffGateEnum;

typedef enum PwrSnsrMeasBuffStartModeEnum
{
    PwrSnsrMeasBuffStartModeImmediate = 1,
    PwrSnsrMeasBuffStartModeExternalEnable = 2,
    PwrSnsrMeasBuffStartModeExternalStart = 3
} PwrSnsrMeasBuffStartModeEnum;

typedef enum PwrSnsrMeasBuffStopReasonEnum
{
    PwrSnsrMeasBuffStopReasonCountReached = 1,
    PwrSnsrMeasBuffStopReasonTimedOut = 2,
    PwrSnsrMeasBuffStopReasonBufferOverran = 3,
    PwrSnsrMeasBuffStopReasonNone = 0
} PwrSnsrMeasBuffStopReasonEnum;

typedef enum PwrSnsrRdgsEnableFlag
{
    PwrSnsrSequenceEnable = 1,
    PwrSnsrStartTimeEnable = 2,
    PwrSnsrDurationEnable = 4,
    PwrSnsrMinEnable = 8,
    PwrSnsrAvgEnable = 16,
    PwrSnsrMaxEnable = 32   
} PwrSnsrRdgsEnableFlag;

typedef enum PwrSnsrErrorCodesEnum
{
    PWR_SNSR_IO_GENERAL = -2147204588, 
    PWR_SNSR_IO_TIMEOUT = -2147204587, 
    PWR_SNSR_MODEL_NOT_SUPPORTED = -2147204586, 
    PWR_SNSR_INV_PARAMETER = -1073807240, 
    PWR_SNSR_ERROR_INVALID_SESSION_HANDLE = -1074130544, 
    PWR_SNSR_ERROR_STATUS_NOT_AVAILABLE = -1074134947, 
    PWR_SNSR_ERROR_RESET_FAILED = -1074134945,
    PWR_SNSR_ERROR_RESOURCE_UNKNOWN = -1074134944, 
    PWR_SNSR_ERROR_ALREADY_INITIALIZED = -1074134943, 
    PWR_SNSR_ERROR_OUT_OF_MEMORY = -1074134954, 
    PWR_SNSR_ERROR_OPERATION_PENDING = -1074134953, 
    PWR_SNSR_ERROR_NULL_POINTER = -1074134952, 
    PWR_SNSR_ERROR_UNEXPECTED_RESPONSE = -1074134951, 
    PWR_SNSR_ERROR_NOT_INITIALIZED = -1074135011, 
    /*libusb errors*/
    PWR_SNSR_LIBUSB_ERROR_IO = -1,

    PWR_SNSR_LIBUSB_ERROR_INVALID_PARAM = -2,

    PWR_SNSR_LIBUSB_ERROR_ACCESS = -3,

    PWR_SNSR_LIBUSB_ERROR_NO_DEVICE = -4,

    PWR_SNSR_LIBUSB_ERROR_NOT_FOUND = -5,

    PWR_SNSR_LIBUSB_ERROR_BUSY = -6,

    PWR_SNSR_LIBUSB_ERROR_TIMEOUT = -7,

    PWR_SNSR_LIBUSB_ERROR_OVERFLOW = -8,

    PWR_SNSR_LIBUSB_ERROR_PIPE = -9,

    PWR_SNSR_LIBUSB_ERROR_INTERRUPTED = -10,

    PWR_SNSR_LIBUSB_ERROR_NO_MEM = -11,

    PWR_SNSR_LIBUSB_ERROR_NOT_SUPPORTED = -12,

    PWR_SNSR_LIBUSB_ERROR_OTHER = -99,
} PwrSnsrErrorCodesEnum;


#ifdef __cplusplus
extern "C" {
#endif


    EXPORT int PwrSnsr_SendSCPICommand(SessionID Vi, const char * Command);
    EXPORT int PwrSnsr_ReadSCPI(SessionID Vi, int ValueBufferSize, long * ValueActualSize, char Value[], int Timeout);

    EXPORT int PwrSnsr_SendSCPIToNamedParser(SessionID Vi, const char * name, const char * Command);
    EXPORT int PwrSnsr_ReadSCPIFromNamedParser(SessionID Vi, const char * name, int ValueBufferSize, long * ValueActualSize, char Value[], int Timeout);

    EXPORT int PwrSnsr_SendSCPIBytes(SessionID Vi, int CommandBufferSize, char Command[]);
    EXPORT int PwrSnsr_ReadSCPIBytes(SessionID Vi, int ValueBufferSize, char Value[], long* ValueActualSize, int Timeout);
 // end of ScpiFunctions


    EXPORT int PwrSnsr_FindResources(const char* Delimiter, int ValBufferSize, char Val[]);
    EXPORT int PwrSnsr_GetMinimumSupportedFirmware(int * Version);
    
    EXPORT int PwrSnsr_SetTimeOut(SessionID Vi, long Milliseconds);
    EXPORT int PwrSnsr_GetTimeOut(SessionID Vi, long* Val);
    EXPORT int PwrSnsr_init(char * ResourceName, SessionID* Vi);
    EXPORT int PwrSnsr_close(SessionID Vi);
    EXPORT int PwrSnsr_GetError(SessionID Vi, int* ErrorCode, int ErrorDescriptionBufferSize, char ErrorDescription[]);
    EXPORT int PwrSnsr_ClearError(SessionID Vi);
    EXPORT int PwrSnsr_reset(SessionID Vi);
    EXPORT int PwrSnsr_self_test(SessionID Vi, int* TestResult);

    

    EXPORT int PwrSnsr_SetFetchLatency(SessionID Vi, int Latency);
    EXPORT int PwrSnsr_GetFetchLatency(SessionID Vi, int *Latency); // end of SessionManagment

    EXPORT int PwrSnsr_MeasurePower(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum* CondCode, float* Val);
    EXPORT int PwrSnsr_FetchCWPower(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum* CondCode, float* Val);
    EXPORT int PwrSnsr_MeasureVoltage(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum* CondCode, float* Val);

    EXPORT int PwrSnsr_ReadWaveformMinMax(SessionID Vi, const char * Channel, int MinWaveformBufferSize, float MinWaveform[], int * MinWaveformActualSize, int MaxWaveformBufferSize, float MaxWaveform[], int * MaxWaveformActualSize, int WaveformArrayBufferSize, float WaveformArray[], int * WaveformArrayActualSize);
    EXPORT int PwrSnsr_ReadWaveform(SessionID Vi, const char * Channel, int WaveformArrayBufferSize, float WaveformArray[], int * WaveformArrayActualSize);

    EXPORT int PwrSnsr_FetchWaveformMinMax(SessionID Vi, const char * Channel, int MinWaveformBufferSize, float MinWaveform[], int * MinWaveformActualSize, int MaxWaveformBufferSize, float MaxWaveform[], int * MaxWaveformActualSize, int WaveformArrayBufferSize, float WaveformArray[], int * WaveformArrayActualSize);
    EXPORT int PwrSnsr_FetchWaveform(SessionID Vi, const char * Channel, int WaveformArrayBufferSize, float WaveformArray[], int * WaveformArrayActualSize);
    EXPORT int PwrSnsr_FetchPowerArray(SessionID Vi, const char * Channel, float* PulsePeak, PwrSnsrCondCodeEnum * PulsePeakValid, float* PulseCycleAvg, PwrSnsrCondCodeEnum * PulseCycleAvgValid,
        float* PulseOnAvg, PwrSnsrCondCodeEnum * PulseOnValid, float* IEEETop, PwrSnsrCondCodeEnum * IEEETopValid, float* IEEEBottom, PwrSnsrCondCodeEnum * IEEEBottomValid,
        float* Overshoot, PwrSnsrCondCodeEnum * OvershootValid, float* Droop, PwrSnsrCondCodeEnum * DroopValid);

    EXPORT int PwrSnsr_FetchTimeArray(SessionID Vi, const char * Channel, float* Frequency, PwrSnsrCondCodeEnum * FrequencyValid, float* Period, PwrSnsrCondCodeEnum * PeriodValid,
        float* Width, PwrSnsrCondCodeEnum * WidthValid, float* Offtime, PwrSnsrCondCodeEnum * OfftimeValid, float* DutyCycle, PwrSnsrCondCodeEnum * DutyCycleValid,
        float* Risetime, PwrSnsrCondCodeEnum * RisetimeValid, float* Falltime, PwrSnsrCondCodeEnum * FalltimeValid, float* EdgeDelay, PwrSnsrCondCodeEnum * EdgeDelayValid,
        float* Skew, PwrSnsrCondCodeEnum * SkewValid);
    EXPORT int PwrSnsr_FetchCWArray(SessionID Vi, const char * Channel, float* PeakAverage, PwrSnsrCondCodeEnum * PeakAverageValid,
        float* PeakMax, PwrSnsrCondCodeEnum * PeakMaxValid, float* PeakMin, PwrSnsrCondCodeEnum * PeakMinValid, 
        float* PeakToAvgRatio, PwrSnsrCondCodeEnum * PeakToAvgRatioValid);
    EXPORT int PwrSnsr_FetchRiseTime(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchWidth(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);

    EXPORT int PwrSnsr_FetchPulsePeak(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchPulseOnAverage(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);

    EXPORT int PwrSnsr_FetchPulseCycleAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);

    EXPORT int PwrSnsr_FetchPRF(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchPeriod(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchOvershoot(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchOfftime(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchIEEETop(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);

    EXPORT int PwrSnsr_FetchIEEEBottom(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchFallTime(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchEdgeDelay(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchDutyCycle(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);

    EXPORT int PwrSnsr_ReadCWPower(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * IsValid, float* Val);

    EXPORT int PwrSnsr_ReadCWArray(SessionID Vi, const char * Channel, float* PeakAverage, PwrSnsrCondCodeEnum * PeakAverageValid, 
        float* PeakMax, PwrSnsrCondCodeEnum * PeakMaxValid, float* PeakMin, PwrSnsrCondCodeEnum * PeakMinValid, 
        float* PeakToAvgRatio, PwrSnsrCondCodeEnum * PeakToAvgRatioValid);
    EXPORT int PwrSnsr_ReadPowerArray(SessionID Vi, const char * Channel, float* PulsePeak, PwrSnsrCondCodeEnum * PulsePeakValid, 
        float* PulseCycleAvg, PwrSnsrCondCodeEnum * PulseCycleAvgValid, float* PulseOnAvg, PwrSnsrCondCodeEnum * PulseOnValid, 
        float* IEEETop, PwrSnsrCondCodeEnum * IEEETopValid, float* IEEEBottom, PwrSnsrCondCodeEnum * IEEEBottomValid, 
        float* Overshoot, PwrSnsrCondCodeEnum * OvershootValid, float* Droop, PwrSnsrCondCodeEnum * DroopValid);
    EXPORT int PwrSnsr_ReadTimeArray(SessionID Vi, const char * Channel, float* Frequency, PwrSnsrCondCodeEnum * FrequencyValid,
        float* Period, PwrSnsrCondCodeEnum * PeriodValid, float* Width, PwrSnsrCondCodeEnum * WidthValid, float* Offtime, 
        PwrSnsrCondCodeEnum * OfftimeValid, float* DutyCycle, PwrSnsrCondCodeEnum * DutyCycleValid, float* Risetime, 
        PwrSnsrCondCodeEnum * RisetimeValid, float* Falltime, PwrSnsrCondCodeEnum * FalltimeValid, float* EdgeDelay, 
        PwrSnsrCondCodeEnum * EdgeDelayValid, float* Skew, PwrSnsrCondCodeEnum * SkewValid);
    
    EXPORT int PwrSnsr_ReadDutyCycle(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadEdgeDelay(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadFallTime(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIEEEBottom(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIEEETop(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadOfftime(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadOvershoot(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadPeriod(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadPRF(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadPulseCycleAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadPulseOnAverage(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadPulsePeak(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadRiseTime(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadWidth(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
 // end of Measurements

    EXPORT int PwrSnsr_GetTrigDelay(SessionID Vi, float* Delay);
    EXPORT int PwrSnsr_SetTrigDelay(SessionID Vi, float Delay);
    EXPORT int PwrSnsr_GetTrigHoldoff(SessionID Vi, float* Holdoff);
    EXPORT int PwrSnsr_SetTrigHoldoff(SessionID Vi, float Holdoff);
    EXPORT int PwrSnsr_GetTrigHoldoffMode(SessionID Vi, PwrSnsrHoldoffModeEnum * HoldoffMode);
    EXPORT int PwrSnsr_SetTrigHoldoffMode(SessionID Vi, PwrSnsrHoldoffModeEnum HoldoffMode);
    EXPORT int PwrSnsr_GetTrigLevel(SessionID Vi, float* Level);
    EXPORT int PwrSnsr_SetTrigLevel(SessionID Vi, float Level);
    EXPORT int PwrSnsr_GetTrigMode(SessionID Vi, PwrSnsrTriggerModeEnum * Mode);
    EXPORT int PwrSnsr_SetTrigMode(SessionID Vi, PwrSnsrTriggerModeEnum Mode);
    EXPORT int PwrSnsr_GetTrigPosition(SessionID Vi, PwrSnsrTriggerPositionEnum * Position);
    EXPORT int PwrSnsr_SetTrigPosition(SessionID Vi, PwrSnsrTriggerPositionEnum Position);
    EXPORT int PwrSnsr_GetTrigSource(SessionID Vi, PwrSnsrTriggerSourceEnum * Source);
    EXPORT int PwrSnsr_SetTrigSource(SessionID Vi, PwrSnsrTriggerSourceEnum Source);
    EXPORT int PwrSnsr_GetTrigStatus(SessionID Vi, PwrSnsrTriggerStatusEnum * Status);
    EXPORT int PwrSnsr_GetTrigVernier(SessionID Vi, float* Vernier);
    EXPORT int PwrSnsr_SetTrigVernier(SessionID Vi, float Vernier);
    EXPORT int PwrSnsr_GetTrigSlope(SessionID Vi, PwrSnsrTriggerSlopeEnum * Slope);
    EXPORT int PwrSnsr_SetTrigSlope(SessionID Vi, PwrSnsrTriggerSlopeEnum Slope);
    EXPORT int PwrSnsr_SetTrigOutMode(SessionID Vi, const char * Channel, int Mode);
 // end of Trigger

    EXPORT int PwrSnsr_Abort(SessionID Vi);

    EXPORT int PwrSnsr_FetchExtendedWaveform(SessionID Vi, const char * Channel, int WaveformArrayBufferSize,
        float WaveformArray[], int* WaveformArrayActualSize, int Count);
    EXPORT int PwrSnsr_Clear(SessionID Vi);
    EXPORT int PwrSnsr_InitiateAquisition(SessionID Vi);
    EXPORT int PwrSnsr_Status(SessionID Vi, PwrSnsrAcquisitionStatusEnum * Val);
    EXPORT int PwrSnsr_SetInitiateContinuous(SessionID Vi, int InitiateContinuous);
    EXPORT int PwrSnsr_GetInitiateContinuous(SessionID Vi, int* InitiateContinuous);

    EXPORT int PwrSnsr_EnableCapturePriority(SessionID Vi, const char * Channel, int Enabled);

 // end of Acquisition


    EXPORT int PwrSnsr_GetChannelByIndex(SessionID Vi, int BuffSize, char Channel[], int Index);

    EXPORT int PwrSnsr_GetEnabled(SessionID Vi, const char * Channel, int* Enabled);
    EXPORT int PwrSnsr_SetEnabled(SessionID Vi, const char * Channel, int Enabled);
    EXPORT int PwrSnsr_GetSerialNumber(SessionID Vi, const char * Channel, int SerialNumberBufferSize, char SerialNumber[]);

    EXPORT int PwrSnsr_GetChannelCount(SessionID Vi, int * Count);

    EXPORT int PwrSnsr_GetUnits(SessionID Vi, const char * Channel, PwrSnsrUnitsEnum * Units);
    EXPORT int PwrSnsr_SetUnits(SessionID Vi, const char * Channel, PwrSnsrUnitsEnum Units);
    EXPORT int PwrSnsr_GetCurrentTemp(SessionID Vi, const char * Channel, double* CurrentTemp);
    EXPORT int PwrSnsr_GetAverage(SessionID Vi, const char * Channel, int * Average);
    EXPORT int PwrSnsr_SetAverage(SessionID Vi, const char * Channel, int Average);
    EXPORT int PwrSnsr_GetBandwidth(SessionID Vi, const char * Channel, PwrSnsrBandwidthEnum * Bandwidth);
    EXPORT int PwrSnsr_SetBandwidth(SessionID Vi, const char * Channel, PwrSnsrBandwidthEnum Bandwidth);
    EXPORT int PwrSnsr_GetFilterState(SessionID Vi, const char * Channel, PwrSnsrFilterStateEnum * FilterState);
    EXPORT int PwrSnsr_SetFilterState(SessionID Vi, const char * Channel, PwrSnsrFilterStateEnum FilterState);
    EXPORT int PwrSnsr_GetFilterTime(SessionID Vi, const char * Channel, float* FilterTime);
    EXPORT int PwrSnsr_SetFilterTime(SessionID Vi, const char * Channel, float FilterTime);
    EXPORT int PwrSnsr_GetIsAvgSensor(SessionID Vi, const char * Channel, int* IsAvgSensor);
    EXPORT int PwrSnsr_GetDistal(SessionID Vi, const char * Channel, float* Distal);
    EXPORT int PwrSnsr_SetDistal(SessionID Vi, const char * Channel, float Distal);
    EXPORT int PwrSnsr_GetEndGate(SessionID Vi, const char * Channel, float* EndGate);
    EXPORT int PwrSnsr_SetEndGate(SessionID Vi, const char * Channel, float EndGate);
    EXPORT int PwrSnsr_GetMesial(SessionID Vi, const char * Channel, float* Mesial);
    EXPORT int PwrSnsr_SetMesial(SessionID Vi, const char * Channel, float Mesial);
    EXPORT int PwrSnsr_GetProximal(SessionID Vi, const char * Channel, float* Proximal);
    EXPORT int PwrSnsr_SetProximal(SessionID Vi, const char * Channel, float Proximal);
    EXPORT int PwrSnsr_GetPulseUnits(SessionID Vi, const char * Channel, PwrSnsrPulseUnitsEnum * Units);
    EXPORT int PwrSnsr_SetPulseUnits(SessionID Vi, const char * Channel, PwrSnsrPulseUnitsEnum PwrSnsrPulseUnitsEnum);
    EXPORT int PwrSnsr_GetStartGate(SessionID Vi, const char * Channel, float* StartGate);
    EXPORT int PwrSnsr_SetStartGate(SessionID Vi, const char * Channel, float StartGate);

    EXPORT int PwrSnsr_GetCalFactors(SessionID Vi, const char * Channel, float* MaxFrequency, float* MinFrequency,
        int FrequencyListBufferSize, float FrequencyList[], int * FrequencyListActualSize,
        int CalFactorListBufferSize, float CalFactorList[], int * CalFactorListActualSize, PwrSnsrBandwidthEnum Bandwidth);

    EXPORT int PwrSnsr_GetCalFactor(SessionID Vi, const char * Channel, float* CalFactor);
    EXPORT int PwrSnsr_SetCalFactor(SessionID Vi, const char * Channel, float CalFactor);
    EXPORT int PwrSnsr_GetFrequency(SessionID Vi, const char * Channel, float* Frequency);
    EXPORT int PwrSnsr_SetFrequency(SessionID Vi, const char * Channel, float Frequency);
    EXPORT int PwrSnsr_GetOffsetdB(SessionID Vi, const char * Channel, float* OffsetdB);
    EXPORT int PwrSnsr_SetOffsetdB(SessionID Vi, const char * Channel, float OffsetdB);
    EXPORT int PwrSnsr_GetTempComp(SessionID Vi, const char * Channel, int* TempComp);
    EXPORT int PwrSnsr_SetTempComp(SessionID Vi, const char * Channel, int TempComp);
    EXPORT int PwrSnsr_GetModel(SessionID Vi, const char * Channel, int ModelBufferSize, char Model[]);

    EXPORT int PwrSnsr_GetPeakHoldDecay(SessionID Vi, const char * Channel, int* EnvelopeAverage);

    EXPORT int PwrSnsr_GetPeakHoldTracking(SessionID Vi, const char * Channel, int* EnvelopeTracking);
    EXPORT int PwrSnsr_SetPeakHoldTracking(SessionID Vi, const char * Channel, int EnvelopeTracking);
    EXPORT int PwrSnsr_GetFirmwareVersion(SessionID Vi, const char * Channel, int FirmwareVersionBufferSize, char FirmwareVersion[]);
    EXPORT int PwrSnsr_SetPeakHoldDecay(SessionID Vi, const char * Channel, int PeakHoldDecay); // end of Channel

    EXPORT int PwrSnsr_GetTimebase(SessionID Vi, float* Timebase);
    EXPORT int PwrSnsr_SetTimebase(SessionID Vi, float Timebase);
    EXPORT int PwrSnsr_SetTimespan(SessionID Vi, float Timespan);
    EXPORT int PwrSnsr_GetTimespan(SessionID Vi, float* Timespan);
    EXPORT int PwrSnsr_GetMaxTimebase(SessionID Vi, float* MaxTimebase);
 // end of Time


    EXPORT int PwrSnsr_GetMarkerTimePosition(SessionID Vi, int MarkerNumber, float* TimePosition);
    EXPORT int PwrSnsr_SetMarkerTimePosition(SessionID Vi, int MarkerNumber, float TimePosition);
    EXPORT int PwrSnsr_GetMarkerPixelPosition(SessionID Vi, int MarkerNumber, int * PixelPosition);
    EXPORT int PwrSnsr_SetMarkerPixelPosition(SessionID Vi, int MarkerNumber, int PixelPosition);
    EXPORT int PwrSnsr_FetchArrayMarkerPower(SessionID Vi, const char * Channel, float* AvgPower,
        PwrSnsrCondCodeEnum * AvgPowerCondCode, float* MaxPower,
        PwrSnsrCondCodeEnum * MaxPowerCondCode, float* MinPower,
        PwrSnsrCondCodeEnum * MinPowerCondCode, float* PkToAvgRatio,
        PwrSnsrCondCodeEnum * PkToAvgRatioCondCode, float* Marker1Power,
        PwrSnsrCondCodeEnum * Marker1PowerCondCode, float* Marker2Power,
        PwrSnsrCondCodeEnum * Marker2PowerCondCode, float* MarkerRatio,
        PwrSnsrCondCodeEnum * MarkerRatioCondCode);
    EXPORT int PwrSnsr_FetchMarkerAverage(SessionID Vi, const char * Channel, int Marker, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchMarkerMax(SessionID Vi, const char * Channel, int Marker, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_FetchMarkerMin(SessionID Vi, const char * Channel, int Marker, PwrSnsrCondCodeEnum * IsValid, float* Val);
    EXPORT int PwrSnsr_ReadArrayMarkerPower(SessionID Vi, const char * Channel, float* AvgPower, PwrSnsrCondCodeEnum * AvgPowerCondCode, float* MaxPower, PwrSnsrCondCodeEnum * MaxPowerCondCode, float* MinPower, PwrSnsrCondCodeEnum * MinPowerCondCode, float* PkToAvgRatio, PwrSnsrCondCodeEnum * PkToAvgRatioCondCode, float* Marker1Power, PwrSnsrCondCodeEnum * Marker1PowerCondCode, float* Marker2Power, PwrSnsrCondCodeEnum * Marker2PowerCondCode, float* MarkerRatio, PwrSnsrCondCodeEnum * MarkerRatioCondCode);
    EXPORT int PwrSnsr_ReadMarkerAverage(SessionID Vi, const char * Channel, int Marker, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadMarkerMax(SessionID Vi, const char * Channel, int Marker, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadMarkerMin(SessionID Vi, const char * Channel, int Marker, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalFilteredMin(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalFilteredMax(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalMax(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalMin(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalPkToAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalFilteredMin(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalFilteredMax(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalMax(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalMin(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalPkToAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalMaxAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchIntervalMinAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalMaxAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadIntervalMinAvg(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchMarkerDelta(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchMarkerRatio(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchMarkerRDelta(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_FetchMarkerRRatio(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);

    EXPORT int PwrSnsr_ReadMarkerDelta(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadMarkerRatio(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadMarkerRDelta(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val);
    EXPORT int PwrSnsr_ReadMarkerRRatio(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, float* Val); // end of Marker

    int EXPORT PwrSnsr_GetVerticalCenter(SessionID Vi, const char * Channel, float * VerticalCenter);
    int EXPORT PwrSnsr_SetVerticalCenter(SessionID Vi, const char * Channel, float  VerticalCenter);
    int EXPORT PwrSnsr_GetVerticalScale(SessionID Vi, const char * Channel, float *  VerticalScale);
    int EXPORT PwrSnsr_SetVerticalScale(SessionID Vi, const char * Channel, float VerticalScale); // end of Display

    EXPORT int PwrSnsr_GetHorizontalOffset(SessionID Vi, const char * Channel, double* HorizontalOffset);
    EXPORT int PwrSnsr_SetHorizontalOffset(SessionID Vi, const char * Channel, double HorizontalOffset);
    EXPORT int PwrSnsr_GetHorizontalScale(SessionID Vi, const char * Channel, double* HorizontalScale);
    EXPORT int PwrSnsr_SetHorizontalScale(SessionID Vi, const char * Channel, double HorizontalScale);
    

    EXPORT int PwrSnsr_FetchCCDFTrace(SessionID Vi, const char * Channel, int TraceBufferSize, float Trace[], int * TraceActualSize);
    EXPORT int PwrSnsr_StatModeReset(SessionID Vi, const char * Channel);
    EXPORT int PwrSnsr_FetchStatMeasurementArray(SessionID Vi, const char * Channel, double* Pavg, PwrSnsrCondCodeEnum * PavgCond, double* Ppeak,
        PwrSnsrCondCodeEnum * PpeakCond, double* Pmin, PwrSnsrCondCodeEnum * PminCond, double* PkToAvgRatio,
        PwrSnsrCondCodeEnum * PkToAvgRatioCond, double* CursorPwr, PwrSnsrCondCodeEnum * CursorPwrCond,
        double* CursorPct, PwrSnsrCondCodeEnum * CursorPctCond, double* SampleCount,
        PwrSnsrCondCodeEnum * SampleCountCond, double* SecondsRun, PwrSnsrCondCodeEnum * SecondsRunCond);

    EXPORT int PwrSnsr_FetchCCDFPower(SessionID Vi, const char * Channel, double Percent, PwrSnsrCondCodeEnum * CondCode, double* Val);
    EXPORT int PwrSnsr_FetchCCDFPercent(SessionID Vi, const char * Channel, double Power, PwrSnsrCondCodeEnum * CondCode, double* Val);
    EXPORT int PwrSnsr_GetCapture(SessionID Vi, const char * Channel, int* Capture);

    EXPORT int PwrSnsr_SetCapture(SessionID Vi, const char * Channel, int Capture);
    EXPORT int PwrSnsr_GetGating(SessionID Vi, const char * Channel, PwrSnsrStatGatingEnum * Gating);
    EXPORT int PwrSnsr_SetGating(SessionID Vi, const char * Channel, PwrSnsrStatGatingEnum Gating);
    EXPORT int PwrSnsr_GetTermAction(SessionID Vi, const char * Channel, PwrSnsrTermActionEnum * TermAction);
    EXPORT int PwrSnsr_SetTermAction(SessionID Vi, const char * Channel, PwrSnsrTermActionEnum TermAction);
    EXPORT int PwrSnsr_GetTermCount(SessionID Vi, const char * Channel, double* TermCount);
    EXPORT int PwrSnsr_SetTermCount(SessionID Vi, const char * Channel, double TermCount);
    EXPORT int PwrSnsr_GetTermTime(SessionID Vi, const char * Channel, int * TermTime);
    EXPORT int PwrSnsr_SetTermTime(SessionID Vi, const char * Channel, int TermTime);
    EXPORT int PwrSnsr_GetCCDFTraceCount(SessionID Vi, const char * Channel, int * TraceCount);
    EXPORT int PwrSnsr_SetCCDFTraceCount(SessionID Vi, const char * Channel, int TraceCount);

    EXPORT int PwrSnsr_FetchCursorPercent(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, double* Val);
    EXPORT int PwrSnsr_FetchCursorPower(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum * CondCode, double* Val);
    EXPORT int PwrSnsr_GetPercentPosition(SessionID Vi, const char * Channel, double* PercentPosition);
    EXPORT int PwrSnsr_SetPercentPosition(SessionID Vi, const char * Channel, double PercentPosition);

    EXPORT int PwrSnsr_SetPowerPosition(SessionID Vi, const char * Channel, double PowerPosition);
    EXPORT int PwrSnsr_GetPowerPosition(SessionID Vi, const char * Channel, double* PowerPosition);

    EXPORT int PwrSnsr_GetAcqStatusArray(SessionID Vi, const char * Channel, int * SweepLength, double* SampleRate, double* SweepRate, double* SweepTime, double* StartTime, int * StatusWord);
    EXPORT int PwrSnsr_GetDiagStatusArray(SessionID Vi, const char * Channel, float* DetectorTemp, float* CpuTemp, float* MioVoltage, float* VccInt10, float* VccAux18, float* Vcc50, float* Vcc25, float* Vcc33); // end of StatisticalMode


    




    EXPORT int PwrSnsr_GetManufactureDate(SessionID Vi, const char * Channel, int ManufactureDateBufferSize, char ManufactureDate[]);
    EXPORT int PwrSnsr_GetImpedance(SessionID Vi, const char * Channel, float* Impedance);
    EXPORT int PwrSnsr_GetPeakPowerMax(SessionID Vi, const char * Channel, float* PeakPowerMax);
    EXPORT int PwrSnsr_GetPeakPowerMin(SessionID Vi, const char * Channel, float* PeakPowerMin);
    EXPORT int PwrSnsr_GetAttenuation(SessionID Vi, const char * Channel, float* Attenuation);
    EXPORT int PwrSnsr_GetFactoryCalDate(SessionID Vi, const char * Channel, int FactoryCalDateBufferSize, char FactoryCalDate[]);
    EXPORT int PwrSnsr_GetMinimumTrig(SessionID Vi, const char * Channel, float* MinimumTrig);
    EXPORT int PwrSnsr_GetMinFreqHighBandwidth(SessionID Vi, const char * Channel, float* MinFreqHighBandwidth);
    EXPORT int PwrSnsr_GetMaxFreqHighBandwidth(SessionID Vi, const char * Channel, float* MaxFreqHighBandwidth);
    EXPORT int PwrSnsr_GetMinFreqLowBandwidth(SessionID Vi, const char * Channel, float* MinFreqLowBandwidth);
    EXPORT int PwrSnsr_GetMaxFreqLowBandwidth(SessionID Vi, const char * Channel, float* MaxFreqLowBandwidth);
    EXPORT int PwrSnsr_GetFpgaVersion(SessionID Vi, const char * Channel, int ValBufferSize, char Val[]);
 // end of SensorInfo


    EXPORT int PwrSnsr_SaveUserCal(SessionID Vi, const char * Channel);
    EXPORT int PwrSnsr_ClearUserCal(SessionID Vi, const char * Channel);

    EXPORT int PwrSnsr_GetExternalSkew(SessionID Vi, const char * Channel, float* External);
    EXPORT int PwrSnsr_SetExternalSkew(SessionID Vi, const char * Channel, float External);
    EXPORT int PwrSnsr_GetSlaveSkew(SessionID Vi, const char * Channel, float* SlaveSkew);
    EXPORT int PwrSnsr_SetSlaveSkew(SessionID Vi, const char * Channel, float SlaveSkew);
    EXPORT int PwrSnsr_GetInternalSkew(SessionID Vi, const char * Channel, float* InternalSkew);
    EXPORT int PwrSnsr_SetInternalSkew(SessionID Vi, const char * Channel, float InternalSkew);
    EXPORT int PwrSnsr_Zero(SessionID Vi, const char * Channel);

    EXPORT int PwrSnsr_ZeroQuery(SessionID Vi, const char * Channel, int* Val); // end of UserCal
    






    EXPORT int PwrSnsr_GetTimePerPoint(SessionID Vi, const char * Channel, float* TimePerPoint);
    EXPORT int PwrSnsr_GetSweepTime(SessionID Vi, const char * Channel, float* SweepTime);
    EXPORT int PwrSnsr_GetChanTraceCount(SessionID Vi, const char * Channel, int* TraceCount);
    EXPORT int PwrSnsr_GetTraceStartTime(SessionID Vi, const char * Channel, float* TraceStartTime);
    EXPORT int PwrSnsr_FetchDistal(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum* CondCode, float* Val);
    EXPORT int PwrSnsr_FetchMesial(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum* CondCode, float* Val);
    EXPORT int PwrSnsr_FetchProximal(SessionID Vi, const char * Channel, PwrSnsrCondCodeEnum* CondCode, float* Val);
 // end of Trace


    typedef struct PulseInfo
    {
        float Width; 
        float Peak; 
        float Min; 
        float PulseAvg; 
        float Position; 
        float RiseProximal; 
        float RiseDistal; 
        float RiseTime; 
        float FallProximal; 
        float FallDistal; 
        float FallTime; 
    }PulseInfo;
    EXPORT int PwrSnsr_FetchAllMultiPulse(SessionID Vi,
        const char * Channel,
        int PulseInfosSize,
        PulseInfo PulseInfos[],
        int* PulseInfosActualSize);
 // end of MultiplePulse

    EXPORT int PwrSnsr_SaveToMemoryChannel(SessionID Vi, const char * MemChan, const char * ChannelName);
    EXPORT int PwrSnsr_GetMemChanArchive(SessionID Vi, const char * MemChan, int ValBufferSize, char Val[]);
    EXPORT int PwrSnsr_LoadMemChanFromArchive(SessionID Vi, const char * MemChan, const char * ArchiveContent); // end of MemChan



    
    EXPORT int PwrSnsr_GetIsAvailable(SessionID Vi, const char * Channel, int* IsAvailable);
    EXPORT int PwrSnsr_GetIsRunning(SessionID Vi, const char * Channel, int* IsRunning);
    EXPORT int PwrSnsr_GetReadingPeriod(SessionID Vi, const char * Channel, float* ReadingPeriod);
    EXPORT int PwrSnsr_GetBufferedAverageMeasurements(SessionID Vi, const char * Channel, int ValBufferSize,
        float Val[], int* ValActualSize);
    EXPORT int PwrSnsr_AcquireMeasurements(SessionID Vi, double Timeout, int Count, PwrSnsrMeasBuffStopReasonEnum* StopReason, int* Val);
    EXPORT int PwrSnsr_GetMaxMeasurements(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_GetMinMeasurements(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_GetDuration(SessionID Vi, float* Duration);
    EXPORT int PwrSnsr_SetDuration(SessionID Vi, float Duration);
    EXPORT int PwrSnsr_GetSequenceNumbers(SessionID Vi, const char * Channel, int ValBufferSize, unsigned int Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_GetStartTimes(SessionID Vi, const char * Channel, int ValBufferSize, double Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_GetDurations(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_StartAcquisition(SessionID Vi);
    EXPORT int PwrSnsr_StopAcquisition(SessionID Vi);
    EXPORT int PwrSnsr_ClearBuffer(SessionID Vi);
    EXPORT int PwrSnsr_ClearMeasurements(SessionID Vi);
    EXPORT int PwrSnsr_GetMeasurementsAvailable(SessionID Vi, const char * Channel, int* Val);
    EXPORT int PwrSnsr_SetPeriod(SessionID Vi, float Period);
    EXPORT int PwrSnsr_GetPeriod(SessionID Vi, float* Period);
    EXPORT int PwrSnsr_GetRdgsEnableFlag(SessionID Vi, int* Flag);
    EXPORT int PwrSnsr_SetRdgsEnableFlag(SessionID Vi, int Flag);
    EXPORT int PwrSnsr_GetGateMode(SessionID Vi, PwrSnsrMeasBuffGateEnum * GateMode);
    EXPORT int PwrSnsr_SetGateMode(SessionID Vi, PwrSnsrMeasBuffGateEnum GateMode);
    EXPORT int PwrSnsr_GetStartMode(SessionID Vi, PwrSnsrMeasBuffStartModeEnum * StartMode);
    EXPORT int PwrSnsr_SetStartMode(SessionID Vi, PwrSnsrMeasBuffStartModeEnum StartMode);
    EXPORT int PwrSnsr_AdvanceReadIndex(SessionID Vi);
    EXPORT int PwrSnsr_QueryAverageMeasurements(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_QueryStartTimes(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_QuerySequenceNumbers(SessionID Vi, const char * Channel, int ValBufferSize, unsigned int Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_QueryDurations(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_QueryMaxMeasurements(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_QueryMinMeasurements(SessionID Vi, const char * Channel, int ValBufferSize, float Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_GetWriteProtection(SessionID Vi, int* WriteProtection);
    EXPORT int PwrSnsr_GetTimedOut(SessionID Vi, int* TimedOut);
    EXPORT int PwrSnsr_GetSessionCount(SessionID Vi, int* SessionCount);
    EXPORT int PwrSnsr_SetSessionCount(SessionID Vi, int SessionCount);
    EXPORT int PwrSnsr_SetSessionTimeout(SessionID Vi, float Seconds);

    EXPORT int PwrSnsr_GetReturnCount(SessionID Vi, int* ReturnCount);
    EXPORT int PwrSnsr_SetReturnCount(SessionID Vi, int ReturnCount);
    EXPORT int PwrSnsr_SetWriteProtection(SessionID Vi, int WriteProtection);
    EXPORT int PwrSnsr_GetOverRan(SessionID Vi, int* OverRan);
    EXPORT int PwrSnsr_GetBufferedMeasurementsAvailable(SessionID Vi, int* MeasurementsAvailable);
    EXPORT int PwrSnsr_GetMeasBuffEnabled(SessionID Vi, int* MeasBuffEnabled);
    EXPORT int PwrSnsr_SetMeasBuffEnabled(SessionID Vi, int MeasBuffEnabled);
    EXPORT int PwrSnsr_ResetContinuousCapture(SessionID Vi);



    EXPORT int PwrSnsr_GetEndDelay(SessionID Vi, float* EndDelay);
    EXPORT int PwrSnsr_SetEndDelay(SessionID Vi, float EndDelay);
    EXPORT int PwrSnsr_GetStartQual(SessionID Vi, float* StartQual);
    EXPORT int PwrSnsr_SetStartQual(SessionID Vi, float StartQual);
    EXPORT int PwrSnsr_GetStartDelay(SessionID Vi, float* StartDelay);
    EXPORT int PwrSnsr_SetStartDelay(SessionID Vi, float StartDelay);
    EXPORT int PwrSnsr_GetEndQual(SessionID Vi, float* EndQual);
    EXPORT int PwrSnsr_SetEndQual(SessionID Vi, float EndQual);
    EXPORT int PwrSnsr_SetContinuousCapture(SessionID Vi, int ContinuousCapture);
    EXPORT int PwrSnsr_GetContinuousCapture(SessionID Vi, int* ContinuousCapture); // End of MeasurementBuffer
    
    EXPORT int PwrSnsr_Write(SessionID Vi, const char * Channel, int DataBufferSize, unsigned char Data[]);
    EXPORT int PwrSnsr_ReadByteArray(SessionID Vi, const char * Channel, int Count, int ValBufferSize, unsigned char Val[],
        int* ValActualSize);
    EXPORT int PwrSnsr_ReadControl(SessionID Vi, const char * Channel, int Count, int ValBufferSize, unsigned char Val[],
        int* ValActualSize); // end of RawIO


    
    EXPORT int PwrSnsr_GetDongleSerialNumber(long* val);
    EXPORT int PwrSnsr_GetExpirationDate(int* Date);
    EXPORT int PwrSnsr_GetNumberOfCals(long * val);
    EXPORT int PwrSnsr_IsLicenseDongleConnected(int * val); // end of License

    typedef enum PwrSnsrSignalUnits
    {
        PwrSnsrSignalUnitsdBm = 0, 
        PwrSnsrSignalUnitsWatts = 1, 
    } PwrSnsrSignalUnits;

    typedef enum PwrSnsrSimSignalType
    {
        PwrSnsrSimSignalPeriodic = 0, 
        PwrSnsrSimSignalBurst = 1, 
    } PwrSnsrSimSignalType;

    typedef enum PwrSnsrSimParamWeight
    {
        PwrSnsrWeightNone = 0, 
        PwrSnsrWeightLight = 1, 
        PwrSnsrWeightMedium = 2, 
        PwrSnsrWeightHeavy = 3, 
    } PwrSnsrSimParamWeight;

    EXPORT int PwrSnsr_OpenSimMeter(int NumChans, char * ResourceBuff, int ResourceBuffSize, SessionID * Vi);

    EXPORT int PwrSnsr_SetSimSignalAmplitude(SessionID Vi, const char * Channel, float Amplitude, PwrSnsrSignalUnits Units);

    EXPORT int PwrSnsr_GetSimSignalAmplitude(SessionID Vi, const char * Channel, float * Amplitude, PwrSnsrSignalUnits Units);

    EXPORT int PwrSnsr_SetSimSignalModulation(SessionID Vi, const char * Channel, PwrSnsrSimParamWeight Weight);

    EXPORT int PwrSnsr_GetSimSignalModulation(SessionID Vi, const char * Channel, PwrSnsrSimParamWeight * Weight);

    EXPORT int PwrSnsr_SetSimSignalCompression(SessionID Vi, const char * Channel, PwrSnsrSimParamWeight Weight);

    EXPORT int PwrSnsr_GetSimSignalCompression(SessionID Vi, const char * Channel, PwrSnsrSimParamWeight * Weight);

    EXPORT int PwrSnsr_SetSimSignalType(SessionID Vi, const char * Channel, PwrSnsrSimSignalType SignalType);

    EXPORT int PwrSnsr_GetSimSignalType(SessionID Vi, const char * Channel, PwrSnsrSimSignalType * SignalType);

    EXPORT int PwrSnsr_SetSimSignalPRF(SessionID Vi, const char * Channel, float PRF);

    EXPORT int PwrSnsr_GetSimSignalPRF(SessionID Vi, const char * Channel, float * PRF);

    EXPORT int PwrSnsr_SetSimSignalDuty(SessionID Vi, const char * Channel, float Duty);

    EXPORT int PwrSnsr_GetSimSignalDuty(SessionID Vi, const char * Channel, float * Duty);
 // end of SensorSimulation



#ifdef __cplusplus
}
#endif

#endif /* PWRSNSRLIB_H */