1pub const PS6000_MAX_OVERSAMPLE_8BIT: u32 = 256;
2pub const PS6000_MAX_VALUE: u32 = 32512;
3pub const PS6000_MIN_VALUE: i32 = -32512;
4pub const MAX_PULSE_WIDTH_QUALIFIER_COUNT: u32 = 16777215;
5pub const MAX_SIG_GEN_BUFFER_SIZE: u32 = 16384;
6pub const PS640X_C_D_MAX_SIG_GEN_BUFFER_SIZE: u32 = 65536;
7pub const MIN_SIG_GEN_BUFFER_SIZE: u32 = 1;
8pub const MIN_DWELL_COUNT: u32 = 3;
9pub const MAX_SWEEPS_SHOTS: u32 = 1073741823;
10pub const MAX_WAVEFORMS_PER_SECOND: u32 = 1000000;
11pub const MAX_ANALOGUE_OFFSET_50MV_200MV: f64 = 0.5;
12pub const MIN_ANALOGUE_OFFSET_50MV_200MV: f64 = -0.5;
13pub const MAX_ANALOGUE_OFFSET_500MV_2V: f64 = 2.5;
14pub const MIN_ANALOGUE_OFFSET_500MV_2V: f64 = -2.5;
15pub const MAX_ANALOGUE_OFFSET_5V_20V: f64 = 20.0;
16pub const MIN_ANALOGUE_OFFSET_5V_20V: f64 = -20.0;
17pub const PS6000_MAX_ETS_CYCLES: u32 = 250;
18pub const PS6000_MAX_INTERLEAVE: u32 = 50;
19pub const PS6000_PRBS_MAX_FREQUENCY: f64 = 20000000.0;
20pub const PS6000_SINE_MAX_FREQUENCY: f64 = 20000000.0;
21pub const PS6000_SQUARE_MAX_FREQUENCY: f64 = 20000000.0;
22pub const PS6000_TRIANGLE_MAX_FREQUENCY: f64 = 20000000.0;
23pub const PS6000_SINC_MAX_FREQUENCY: f64 = 20000000.0;
24pub const PS6000_RAMP_MAX_FREQUENCY: f64 = 20000000.0;
25pub const PS6000_HALF_SINE_MAX_FREQUENCY: f64 = 20000000.0;
26pub const PS6000_GAUSSIAN_MAX_FREQUENCY: f64 = 20000000.0;
27pub const PS6000_MIN_FREQUENCY: f64 = 0.03;
28
29pub type PICO_POINTER = *mut ::std::os::raw::c_void;
30pub type PICO_INFO = u32;
31pub type PICO_STATUS = u32;
32pub const enPicoStringValue_PICO_SV_MEMORY: enPicoStringValue = 0;
33pub const enPicoStringValue_PICO_SV_MEMORY_NO_OF_SEGMENTS: enPicoStringValue = 1;
34pub const enPicoStringValue_PICO_SV_MEMORY_MAX_SAMPLES: enPicoStringValue = 2;
35pub const enPicoStringValue_PICO_SV_NO_OF_CHANNELS: enPicoStringValue = 3;
36pub const enPicoStringValue_PICO_SV_ARRAY_OF_CHANNELS: enPicoStringValue = 4;
37pub const enPicoStringValue_PICO_SV_CHANNEL: enPicoStringValue = 5;
38pub const enPicoStringValue_PICO_SV_CHANNEL_NAME: enPicoStringValue = 6;
39pub const enPicoStringValue_PICO_SV_CHANNEL_RANGE: enPicoStringValue = 7;
40pub const enPicoStringValue_PICO_SV_CHANNEL_COUPLING: enPicoStringValue = 8;
41pub const enPicoStringValue_PICO_SV_CHANNEL_ENABLED: enPicoStringValue = 9;
42pub const enPicoStringValue_PICO_SV_CHANNEL_ANALOGUE_OFFSET: enPicoStringValue = 10;
43pub const enPicoStringValue_PICO_SV_CHANNEL_FILTER: enPicoStringValue = 11;
44pub const enPicoStringValue_PICO_SV_TRIGGER: enPicoStringValue = 12;
45pub const enPicoStringValue_PICO_SV_TRIGGER_AUXIO_OUTPUT_ENABLED: enPicoStringValue = 13;
46pub const enPicoStringValue_PICO_SV_TRIGGER_AUTO_TRIGGER_MICROSECONDS: enPicoStringValue = 14;
47pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES: enPicoStringValue = 15;
48pub const enPicoStringValue_PICO_SV_NO_OF_TRIGGER_PROPERTIES: enPicoStringValue = 16;
49pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES_CHANNEL: enPicoStringValue = 17;
50pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES_THRESHOLD_UPPER: enPicoStringValue = 18;
51pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES_THRESHOLD_UPPER_HYSTERESIS:
52 enPicoStringValue = 19;
53pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES_THRESHOLD_LOWER: enPicoStringValue = 20;
54pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES_THRESHOLD_LOWER_HYSTERESIS:
55 enPicoStringValue = 21;
56pub const enPicoStringValue_PICO_SV_TRIGGER_PROPERTIES_THRESHOLD_MODE: enPicoStringValue = 22;
57pub const enPicoStringValue_PICO_SV_TRIGGER_ARRAY_OF_BLOCK_CONDITIONS: enPicoStringValue = 23;
58pub const enPicoStringValue_PICO_SV_TRIGGER_NO_OF_BLOCK_CONDITIONS: enPicoStringValue = 24;
59pub const enPicoStringValue_PICO_SV_TRIGGER_CONDITIONS: enPicoStringValue = 25;
60pub const enPicoStringValue_PICO_SV_TRIGGER_NO_OF_CONDITIONS: enPicoStringValue = 26;
61pub const enPicoStringValue_PICO_SV_TRIGGER_CONDITION_SOURCE: enPicoStringValue = 27;
62pub const enPicoStringValue_PICO_SV_TRIGGER_CONDITION_STATE: enPicoStringValue = 28;
63pub const enPicoStringValue_PICO_SV_TRIGGER_DIRECTION: enPicoStringValue = 29;
64pub const enPicoStringValue_PICO_SV_TRIGGER_NO_OF_DIRECTIONS: enPicoStringValue = 30;
65pub const enPicoStringValue_PICO_SV_TRIGGER_DIRECTION_CHANNEL: enPicoStringValue = 31;
66pub const enPicoStringValue_PICO_SV_TRIGGER_DIRECTION_DIRECTION: enPicoStringValue = 32;
67pub const enPicoStringValue_PICO_SV_TRIGGER_DELAY: enPicoStringValue = 33;
68pub const enPicoStringValue_PICO_SV_TRIGGER_DELAY_MS: enPicoStringValue = 34;
69pub const enPicoStringValue_PICO_SV_FREQUENCY_COUNTER: enPicoStringValue = 35;
70pub const enPicoStringValue_PICO_SV_FREQUENCY_COUNTER_ENABLED: enPicoStringValue = 36;
71pub const enPicoStringValue_PICO_SV_FREQUENCY_COUNTER_CHANNEL: enPicoStringValue = 37;
72pub const enPicoStringValue_PICO_SV_FREQUENCY_COUNTER_RANGE: enPicoStringValue = 38;
73pub const enPicoStringValue_PICO_SV_FREQUENCY_COUNTER_TRESHOLDMAJOR: enPicoStringValue = 39;
74pub const enPicoStringValue_PICO_SV_FREQUENCY_COUNTER_TRESHOLDMINOR: enPicoStringValue = 40;
75pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_PROPERTIES: enPicoStringValue = 41;
76pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_PROPERTIES_DIRECTION: enPicoStringValue = 42;
77pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_PROPERTIES_LOWER: enPicoStringValue = 43;
78pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_PROPERTIES_UPPER: enPicoStringValue = 44;
79pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_PROPERTIES_TYPE: enPicoStringValue = 45;
80pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_ARRAY_OF_BLOCK_CONDITIONS: enPicoStringValue = 46;
81pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_NO_OF_BLOCK_CONDITIONS: enPicoStringValue = 47;
82pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_CONDITIONS: enPicoStringValue = 48;
83pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_NO_OF_CONDITIONS: enPicoStringValue = 49;
84pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_CONDITIONS_SOURCE: enPicoStringValue = 50;
85pub const enPicoStringValue_PICO_SV_PULSE_WIDTH_CONDITIONS_STATE: enPicoStringValue = 51;
86pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES: enPicoStringValue = 52;
87pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_PRE_TRIGGER_SAMPLES: enPicoStringValue = 53;
88pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_POST_TRIGGER_SAMPLES: enPicoStringValue = 54;
89pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_TIMEBASE: enPicoStringValue = 55;
90pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_NO_OF_CAPTURES: enPicoStringValue = 56;
91pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_RESOLUTION: enPicoStringValue = 57;
92pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_OVERLAPPED: enPicoStringValue = 58;
93pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_OVERLAPPED_DOWN_SAMPLE_RATIO:
94 enPicoStringValue = 59;
95pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_OVERLAPPED_DOWN_SAMPLE_RATIO_MODE:
96 enPicoStringValue = 60;
97pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_OVERLAPPED_REQUERSTED_NO_OF_SAMPLES:
98 enPicoStringValue = 61;
99pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_OVERLAPPED_SEGMENT_INDEX_FROM:
100 enPicoStringValue = 62;
101pub const enPicoStringValue_PICO_SV_SAMPLE_PROPERTIES_OVERLAPPED_SEGMENT_INDEX_TO:
102 enPicoStringValue = 63;
103pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR: enPicoStringValue = 64;
104pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_BUILT_IN: enPicoStringValue = 65;
105pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_BUILT_IN_WAVE_TYPE: enPicoStringValue = 66;
106pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_BUILT_IN_START_FREQUENCY: enPicoStringValue =
107 67;
108pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_BUILT_IN_STOP_FREQUENCY: enPicoStringValue =
109 68;
110pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_BUILT_IN_INCREMENT: enPicoStringValue = 69;
111pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_BUILT_IN_DWELL_TIME: enPicoStringValue = 70;
112pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG: enPicoStringValue = 71;
113pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG_START_DELTA_PHASE: enPicoStringValue = 72;
114pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG_STOP_DELTA_PHASE: enPicoStringValue = 73;
115pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG_DELTA_PHASE_INCREMENT: enPicoStringValue =
116 74;
117pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG_DWELL_COUNT: enPicoStringValue = 75;
118pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG_INDEX_MODE: enPicoStringValue = 76;
119pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_AWG_WAVEFORM_SIZE: enPicoStringValue = 77;
120pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_ARRAY_OF_AWG_WAVEFORM_VALUES:
121 enPicoStringValue = 78;
122pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_OFFSET_VOLTAGE: enPicoStringValue = 79;
123pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_PK_TO_PK: enPicoStringValue = 80;
124pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_OPERATION: enPicoStringValue = 81;
125pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_SHOTS: enPicoStringValue = 82;
126pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_SWEEPS: enPicoStringValue = 83;
127pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_SWEEP_TYPE: enPicoStringValue = 84;
128pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_TRIGGER_TYPE: enPicoStringValue = 85;
129pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_TRIGGER_SOURCE: enPicoStringValue = 86;
130pub const enPicoStringValue_PICO_SV_SIGNAL_GENERATOR_EXT_IN_THRESHOLD: enPicoStringValue = 87;
131pub const enPicoStringValue_PICO_SV_ETS: enPicoStringValue = 88;
132pub const enPicoStringValue_PICO_SV_ETS_STATE: enPicoStringValue = 89;
133pub const enPicoStringValue_PICO_SV_ETS_CYCLE: enPicoStringValue = 90;
134pub const enPicoStringValue_PICO_SV_ETS_INTERLEAVE: enPicoStringValue = 91;
135pub const enPicoStringValue_PICO_SV_ETS_SAMPLE_TIME_PICOSECONDS: enPicoStringValue = 92;
136pub type enPicoStringValue = ::std::os::raw::c_uint;
137pub use self::enPicoStringValue as PICO_STRING_VALUE;
138pub const enPS6000ExternalFrequency_PS6000_FREQUENCY_OFF: enPS6000ExternalFrequency = 0;
139pub const enPS6000ExternalFrequency_PS6000_FREQUENCY_5MHZ: enPS6000ExternalFrequency = 1;
140pub const enPS6000ExternalFrequency_PS6000_FREQUENCY_10MHZ: enPS6000ExternalFrequency = 2;
141pub const enPS6000ExternalFrequency_PS6000_FREQUENCY_20MHZ: enPS6000ExternalFrequency = 3;
142pub const enPS6000ExternalFrequency_PS6000_FREQUENCY_25MHZ: enPS6000ExternalFrequency = 4;
143pub const enPS6000ExternalFrequency_PS6000_MAX_FREQUENCIES: enPS6000ExternalFrequency = 5;
144pub type enPS6000ExternalFrequency = ::std::os::raw::c_uint;
145pub use self::enPS6000ExternalFrequency as PS6000_EXTERNAL_FREQUENCY;
146pub const enPS6000BandwidthLimiter_PS6000_BW_FULL: enPS6000BandwidthLimiter = 0;
147pub const enPS6000BandwidthLimiter_PS6000_BW_20MHZ: enPS6000BandwidthLimiter = 1;
148pub const enPS6000BandwidthLimiter_PS6000_BW_25MHZ: enPS6000BandwidthLimiter = 2;
149pub type enPS6000BandwidthLimiter = ::std::os::raw::c_uint;
150pub use self::enPS6000BandwidthLimiter as PS6000_BANDWIDTH_LIMITER;
151pub const enPS6000Channel_PS6000_CHANNEL_A: enPS6000Channel = 0;
152pub const enPS6000Channel_PS6000_CHANNEL_B: enPS6000Channel = 1;
153pub const enPS6000Channel_PS6000_CHANNEL_C: enPS6000Channel = 2;
154pub const enPS6000Channel_PS6000_CHANNEL_D: enPS6000Channel = 3;
155pub const enPS6000Channel_PS6000_EXTERNAL: enPS6000Channel = 4;
156pub const enPS6000Channel_PS6000_MAX_CHANNELS: enPS6000Channel = 4;
157pub const enPS6000Channel_PS6000_TRIGGER_AUX: enPS6000Channel = 5;
158pub const enPS6000Channel_PS6000_MAX_TRIGGER_SOURCES: enPS6000Channel = 6;
159pub type enPS6000Channel = ::std::os::raw::c_uint;
160pub use self::enPS6000Channel as PS6000_CHANNEL;
161pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_A_MAX: enPS6000ChannelBufferIndex = 0;
162pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_A_MIN: enPS6000ChannelBufferIndex = 1;
163pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_B_MAX: enPS6000ChannelBufferIndex = 2;
164pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_B_MIN: enPS6000ChannelBufferIndex = 3;
165pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_C_MAX: enPS6000ChannelBufferIndex = 4;
166pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_C_MIN: enPS6000ChannelBufferIndex = 5;
167pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_D_MAX: enPS6000ChannelBufferIndex = 6;
168pub const enPS6000ChannelBufferIndex_PS6000_CHANNEL_D_MIN: enPS6000ChannelBufferIndex = 7;
169pub const enPS6000ChannelBufferIndex_PS6000_MAX_CHANNEL_BUFFERS: enPS6000ChannelBufferIndex = 8;
170pub type enPS6000ChannelBufferIndex = ::std::os::raw::c_uint;
171pub use self::enPS6000ChannelBufferIndex as PS6000_CHANNEL_BUFFER_INDEX;
172pub const enPS6000Range_PS6000_10MV: enPS6000Range = 0;
173pub const enPS6000Range_PS6000_20MV: enPS6000Range = 1;
174pub const enPS6000Range_PS6000_50MV: enPS6000Range = 2;
175pub const enPS6000Range_PS6000_100MV: enPS6000Range = 3;
176pub const enPS6000Range_PS6000_200MV: enPS6000Range = 4;
177pub const enPS6000Range_PS6000_500MV: enPS6000Range = 5;
178pub const enPS6000Range_PS6000_1V: enPS6000Range = 6;
179pub const enPS6000Range_PS6000_2V: enPS6000Range = 7;
180pub const enPS6000Range_PS6000_5V: enPS6000Range = 8;
181pub const enPS6000Range_PS6000_10V: enPS6000Range = 9;
182pub const enPS6000Range_PS6000_20V: enPS6000Range = 10;
183pub const enPS6000Range_PS6000_50V: enPS6000Range = 11;
184pub const enPS6000Range_PS6000_MAX_RANGES: enPS6000Range = 12;
185pub type enPS6000Range = ::std::os::raw::c_uint;
186pub use self::enPS6000Range as PS6000_RANGE;
187pub const enPS6000Coupling_PS6000_AC: enPS6000Coupling = 0;
188pub const enPS6000Coupling_PS6000_DC_1M: enPS6000Coupling = 1;
189pub const enPS6000Coupling_PS6000_DC_50R: enPS6000Coupling = 2;
190pub type enPS6000Coupling = ::std::os::raw::c_uint;
191pub use self::enPS6000Coupling as PS6000_COUPLING;
192pub const enPS6000EtsMode_PS6000_ETS_OFF: enPS6000EtsMode = 0;
193pub const enPS6000EtsMode_PS6000_ETS_FAST: enPS6000EtsMode = 1;
194pub const enPS6000EtsMode_PS6000_ETS_SLOW: enPS6000EtsMode = 2;
195pub const enPS6000EtsMode_PS6000_ETS_MODES_MAX: enPS6000EtsMode = 3;
196pub type enPS6000EtsMode = ::std::os::raw::c_uint;
197pub use self::enPS6000EtsMode as PS6000_ETS_MODE;
198pub const enPS6000TimeUnits_PS6000_FS: enPS6000TimeUnits = 0;
199pub const enPS6000TimeUnits_PS6000_PS: enPS6000TimeUnits = 1;
200pub const enPS6000TimeUnits_PS6000_NS: enPS6000TimeUnits = 2;
201pub const enPS6000TimeUnits_PS6000_US: enPS6000TimeUnits = 3;
202pub const enPS6000TimeUnits_PS6000_MS: enPS6000TimeUnits = 4;
203pub const enPS6000TimeUnits_PS6000_S: enPS6000TimeUnits = 5;
204pub const enPS6000TimeUnits_PS6000_MAX_TIME_UNITS: enPS6000TimeUnits = 6;
205pub type enPS6000TimeUnits = ::std::os::raw::c_uint;
206pub use self::enPS6000TimeUnits as PS6000_TIME_UNITS;
207pub const enPS6000SweepType_PS6000_UP: enPS6000SweepType = 0;
208pub const enPS6000SweepType_PS6000_DOWN: enPS6000SweepType = 1;
209pub const enPS6000SweepType_PS6000_UPDOWN: enPS6000SweepType = 2;
210pub const enPS6000SweepType_PS6000_DOWNUP: enPS6000SweepType = 3;
211pub const enPS6000SweepType_PS6000_MAX_SWEEP_TYPES: enPS6000SweepType = 4;
212pub type enPS6000SweepType = ::std::os::raw::c_uint;
213pub use self::enPS6000SweepType as PS6000_SWEEP_TYPE;
214pub const enPS6000WaveType_PS6000_SINE: enPS6000WaveType = 0;
215pub const enPS6000WaveType_PS6000_SQUARE: enPS6000WaveType = 1;
216pub const enPS6000WaveType_PS6000_TRIANGLE: enPS6000WaveType = 2;
217pub const enPS6000WaveType_PS6000_RAMP_UP: enPS6000WaveType = 3;
218pub const enPS6000WaveType_PS6000_RAMP_DOWN: enPS6000WaveType = 4;
219pub const enPS6000WaveType_PS6000_SINC: enPS6000WaveType = 5;
220pub const enPS6000WaveType_PS6000_GAUSSIAN: enPS6000WaveType = 6;
221pub const enPS6000WaveType_PS6000_HALF_SINE: enPS6000WaveType = 7;
222pub const enPS6000WaveType_PS6000_DC_VOLTAGE: enPS6000WaveType = 8;
223pub const enPS6000WaveType_PS6000_MAX_WAVE_TYPES: enPS6000WaveType = 9;
224pub type enPS6000WaveType = ::std::os::raw::c_uint;
225pub use self::enPS6000WaveType as PS6000_WAVE_TYPE;
226pub const enPS6000ExtraOperations_PS6000_ES_OFF: enPS6000ExtraOperations = 0;
227pub const enPS6000ExtraOperations_PS6000_WHITENOISE: enPS6000ExtraOperations = 1;
228pub const enPS6000ExtraOperations_PS6000_PRBS: enPS6000ExtraOperations = 2;
229pub type enPS6000ExtraOperations = ::std::os::raw::c_uint;
230pub use self::enPS6000ExtraOperations as PS6000_EXTRA_OPERATIONS;
231pub const enPS6000SigGenTrigType_PS6000_SIGGEN_RISING: enPS6000SigGenTrigType = 0;
232pub const enPS6000SigGenTrigType_PS6000_SIGGEN_FALLING: enPS6000SigGenTrigType = 1;
233pub const enPS6000SigGenTrigType_PS6000_SIGGEN_GATE_HIGH: enPS6000SigGenTrigType = 2;
234pub const enPS6000SigGenTrigType_PS6000_SIGGEN_GATE_LOW: enPS6000SigGenTrigType = 3;
235pub type enPS6000SigGenTrigType = ::std::os::raw::c_uint;
236pub use self::enPS6000SigGenTrigType as PS6000_SIGGEN_TRIG_TYPE;
237pub const enPS6000SigGenTrigSource_PS6000_SIGGEN_NONE: enPS6000SigGenTrigSource = 0;
238pub const enPS6000SigGenTrigSource_PS6000_SIGGEN_SCOPE_TRIG: enPS6000SigGenTrigSource = 1;
239pub const enPS6000SigGenTrigSource_PS6000_SIGGEN_AUX_IN: enPS6000SigGenTrigSource = 2;
240pub const enPS6000SigGenTrigSource_PS6000_SIGGEN_EXT_IN: enPS6000SigGenTrigSource = 3;
241pub const enPS6000SigGenTrigSource_PS6000_SIGGEN_SOFT_TRIG: enPS6000SigGenTrigSource = 4;
242pub const enPS6000SigGenTrigSource_PS6000_SIGGEN_TRIGGER_RAW: enPS6000SigGenTrigSource = 5;
243pub type enPS6000SigGenTrigSource = ::std::os::raw::c_uint;
244pub use self::enPS6000SigGenTrigSource as PS6000_SIGGEN_TRIG_SOURCE;
245pub const enPS6000IndexMode_PS6000_SINGLE: enPS6000IndexMode = 0;
246pub const enPS6000IndexMode_PS6000_DUAL: enPS6000IndexMode = 1;
247pub const enPS6000IndexMode_PS6000_QUAD: enPS6000IndexMode = 2;
248pub const enPS6000IndexMode_PS6000_MAX_INDEX_MODES: enPS6000IndexMode = 3;
249pub type enPS6000IndexMode = ::std::os::raw::c_uint;
250pub use self::enPS6000IndexMode as PS6000_INDEX_MODE;
251pub const enPS6000ThresholdMode_PS6000_LEVEL: enPS6000ThresholdMode = 0;
252pub const enPS6000ThresholdMode_PS6000_WINDOW: enPS6000ThresholdMode = 1;
253pub type enPS6000ThresholdMode = ::std::os::raw::c_uint;
254pub use self::enPS6000ThresholdMode as PS6000_THRESHOLD_MODE;
255pub const enPS6000ThresholdDirection_PS6000_ABOVE: enPS6000ThresholdDirection = 0;
256pub const enPS6000ThresholdDirection_PS6000_BELOW: enPS6000ThresholdDirection = 1;
257pub const enPS6000ThresholdDirection_PS6000_RISING: enPS6000ThresholdDirection = 2;
258pub const enPS6000ThresholdDirection_PS6000_FALLING: enPS6000ThresholdDirection = 3;
259pub const enPS6000ThresholdDirection_PS6000_RISING_OR_FALLING: enPS6000ThresholdDirection = 4;
260pub const enPS6000ThresholdDirection_PS6000_ABOVE_LOWER: enPS6000ThresholdDirection = 5;
261pub const enPS6000ThresholdDirection_PS6000_BELOW_LOWER: enPS6000ThresholdDirection = 6;
262pub const enPS6000ThresholdDirection_PS6000_RISING_LOWER: enPS6000ThresholdDirection = 7;
263pub const enPS6000ThresholdDirection_PS6000_FALLING_LOWER: enPS6000ThresholdDirection = 8;
264pub const enPS6000ThresholdDirection_PS6000_INSIDE: enPS6000ThresholdDirection = 0;
265pub const enPS6000ThresholdDirection_PS6000_OUTSIDE: enPS6000ThresholdDirection = 1;
266pub const enPS6000ThresholdDirection_PS6000_ENTER: enPS6000ThresholdDirection = 2;
267pub const enPS6000ThresholdDirection_PS6000_EXIT: enPS6000ThresholdDirection = 3;
268pub const enPS6000ThresholdDirection_PS6000_ENTER_OR_EXIT: enPS6000ThresholdDirection = 4;
269pub const enPS6000ThresholdDirection_PS6000_POSITIVE_RUNT: enPS6000ThresholdDirection = 9;
270pub const enPS6000ThresholdDirection_PS6000_NEGATIVE_RUNT: enPS6000ThresholdDirection = 10;
271pub const enPS6000ThresholdDirection_PS6000_NONE: enPS6000ThresholdDirection = 2;
272pub type enPS6000ThresholdDirection = ::std::os::raw::c_uint;
273pub use self::enPS6000ThresholdDirection as PS6000_THRESHOLD_DIRECTION;
274pub const enPS6000TriggerState_PS6000_CONDITION_DONT_CARE: enPS6000TriggerState = 0;
275pub const enPS6000TriggerState_PS6000_CONDITION_TRUE: enPS6000TriggerState = 1;
276pub const enPS6000TriggerState_PS6000_CONDITION_FALSE: enPS6000TriggerState = 2;
277pub const enPS6000TriggerState_PS6000_CONDITION_MAX: enPS6000TriggerState = 3;
278pub type enPS6000TriggerState = ::std::os::raw::c_uint;
279pub use self::enPS6000TriggerState as PS6000_TRIGGER_STATE;
280#[repr(C, packed)]
281#[derive(Debug, Copy, Clone)]
282pub struct tPS6000TriggerInfo {
283 pub status: PICO_STATUS,
284 pub segmentIndex: u32,
285 pub triggerIndex: u32,
286 pub triggerTime: i64,
287 pub timeUnits: i16,
288 pub reserved0: i16,
289 pub timeStampCounter: u64,
290}
291
292pub type PS6000_TRIGGER_INFO = tPS6000TriggerInfo;
293#[repr(C, packed)]
294#[derive(Debug, Copy, Clone)]
295pub struct tPS6000TriggerConditions {
296 pub channelA: PS6000_TRIGGER_STATE,
297 pub channelB: PS6000_TRIGGER_STATE,
298 pub channelC: PS6000_TRIGGER_STATE,
299 pub channelD: PS6000_TRIGGER_STATE,
300 pub external: PS6000_TRIGGER_STATE,
301 pub aux: PS6000_TRIGGER_STATE,
302 pub pulseWidthQualifier: PS6000_TRIGGER_STATE,
303}
304
305pub type PS6000_TRIGGER_CONDITIONS = tPS6000TriggerConditions;
306#[repr(C, packed)]
307#[derive(Debug, Copy, Clone)]
308pub struct tPS6000PwqConditions {
309 pub channelA: PS6000_TRIGGER_STATE,
310 pub channelB: PS6000_TRIGGER_STATE,
311 pub channelC: PS6000_TRIGGER_STATE,
312 pub channelD: PS6000_TRIGGER_STATE,
313 pub external: PS6000_TRIGGER_STATE,
314 pub aux: PS6000_TRIGGER_STATE,
315}
316
317pub type PS6000_PWQ_CONDITIONS = tPS6000PwqConditions;
318#[repr(C, packed)]
319#[derive(Debug, Copy, Clone)]
320pub struct tPS6000TriggerChannelProperties {
321 pub thresholdUpper: i16,
322 pub hysteresisUpper: u16,
323 pub thresholdLower: i16,
324 pub hysteresisLower: u16,
325 pub channel: PS6000_CHANNEL,
326 pub thresholdMode: PS6000_THRESHOLD_MODE,
327}
328
329pub type PS6000_TRIGGER_CHANNEL_PROPERTIES = tPS6000TriggerChannelProperties;
330pub const enPS6000RatioMode_PS6000_RATIO_MODE_NONE: enPS6000RatioMode = 0;
331pub const enPS6000RatioMode_PS6000_RATIO_MODE_AGGREGATE: enPS6000RatioMode = 1;
332pub const enPS6000RatioMode_PS6000_RATIO_MODE_AVERAGE: enPS6000RatioMode = 2;
333pub const enPS6000RatioMode_PS6000_RATIO_MODE_DECIMATE: enPS6000RatioMode = 4;
334pub const enPS6000RatioMode_PS6000_RATIO_MODE_DISTRIBUTION: enPS6000RatioMode = 8;
335pub type enPS6000RatioMode = ::std::os::raw::c_uint;
336pub use self::enPS6000RatioMode as PS6000_RATIO_MODE;
337pub const enPS6000PulseWidthType_PS6000_PW_TYPE_NONE: enPS6000PulseWidthType = 0;
338pub const enPS6000PulseWidthType_PS6000_PW_TYPE_LESS_THAN: enPS6000PulseWidthType = 1;
339pub const enPS6000PulseWidthType_PS6000_PW_TYPE_GREATER_THAN: enPS6000PulseWidthType = 2;
340pub const enPS6000PulseWidthType_PS6000_PW_TYPE_IN_RANGE: enPS6000PulseWidthType = 3;
341pub const enPS6000PulseWidthType_PS6000_PW_TYPE_OUT_OF_RANGE: enPS6000PulseWidthType = 4;
342pub type enPS6000PulseWidthType = ::std::os::raw::c_uint;
343pub use self::enPS6000PulseWidthType as PS6000_PULSE_WIDTH_TYPE;
344pub const enPS6000Temperatures_PS6000_WHAT_ARE_AVAILABLE: enPS6000Temperatures = 0;
345pub const enPS6000Temperatures_PS6000_INTERNAL_TEMPERATURE: enPS6000Temperatures = 1;
346pub type enPS6000Temperatures = ::std::os::raw::c_uint;
347pub use self::enPS6000Temperatures as PS6000_TEMPERATURES;
348pub type ps6000BlockReady = ::std::option::Option<
349 unsafe extern "C" fn(handle: i16, status: PICO_STATUS, pParameter: *mut ::std::os::raw::c_void),
350>;
351pub type ps6000StreamingReady = ::std::option::Option<
352 unsafe extern "C" fn(
353 handle: i16,
354 noOfSamples: u32,
355 startIndex: u32,
356 overflow: i16,
357 triggerAt: u32,
358 triggered: i16,
359 autoStop: i16,
360 pParameter: *mut ::std::os::raw::c_void,
361 ),
362>;
363pub type ps6000DataReady = ::std::option::Option<
364 unsafe extern "C" fn(
365 handle: i16,
366 status: PICO_STATUS,
367 noOfSamples: u32,
368 overflow: i16,
369 pParameter: *mut ::std::os::raw::c_void,
370 ),
371>;
372
373extern crate libloading;
374pub struct PS6000Loader {
375 __library: ::libloading::Library,
376 pub ps6000ApplyFix: Result<unsafe extern "C" fn(u32, u16), ::libloading::Error>,
377 pub ps6000OpenUnit: Result<
378 unsafe extern "C" fn(handle: *mut i16, serial: *mut i8) -> PICO_STATUS,
379 ::libloading::Error,
380 >,
381 pub ps6000OpenUnitAsync: Result<
382 unsafe extern "C" fn(status: *mut i16, serial: *mut i8) -> PICO_STATUS,
383 ::libloading::Error,
384 >,
385 pub ps6000OpenUnitProgress: Result<
386 unsafe extern "C" fn(
387 handle: *mut i16,
388 progressPercent: *mut i16,
389 complete: *mut i16,
390 ) -> PICO_STATUS,
391 ::libloading::Error,
392 >,
393 pub ps6000GetUnitInfo: Result<
394 unsafe extern "C" fn(
395 handle: i16,
396 string: *mut i8,
397 stringLength: i16,
398 requiredSize: *mut i16,
399 info: PICO_INFO,
400 ) -> PICO_STATUS,
401 ::libloading::Error,
402 >,
403 pub ps6000FlashLed:
404 Result<unsafe extern "C" fn(handle: i16, start: i16) -> PICO_STATUS, ::libloading::Error>,
405 pub ps6000CloseUnit:
406 Result<unsafe extern "C" fn(handle: i16) -> PICO_STATUS, ::libloading::Error>,
407 pub ps6000MemorySegments: Result<
408 unsafe extern "C" fn(handle: i16, nSegments: u32, nMaxSamples: *mut u32) -> PICO_STATUS,
409 ::libloading::Error,
410 >,
411 pub ps6000SetChannel: Result<
412 unsafe extern "C" fn(
413 handle: i16,
414 channel: PS6000_CHANNEL,
415 enabled: i16,
416 type_: PS6000_COUPLING,
417 range: PS6000_RANGE,
418 analogueOffset: f32,
419 bandwidth: PS6000_BANDWIDTH_LIMITER,
420 ) -> PICO_STATUS,
421 ::libloading::Error,
422 >,
423 pub ps6000GetTimebase: Result<
424 unsafe extern "C" fn(
425 handle: i16,
426 timebase: u32,
427 noSamples: u32,
428 timeIntervalNanoseconds: *mut i32,
429 oversample: i16,
430 maxSamples: *mut u32,
431 segmentIndex: u32,
432 ) -> PICO_STATUS,
433 ::libloading::Error,
434 >,
435 pub ps6000GetTimebase2: Result<
436 unsafe extern "C" fn(
437 handle: i16,
438 timebase: u32,
439 noSamples: u32,
440 timeIntervalNanoseconds: *mut f32,
441 oversample: i16,
442 maxSamples: *mut u32,
443 segmentIndex: u32,
444 ) -> PICO_STATUS,
445 ::libloading::Error,
446 >,
447 pub ps6000SetSigGenArbitrary: Result<
448 unsafe extern "C" fn(
449 handle: i16,
450 offsetVoltage: i32,
451 pkToPk: u32,
452 startDeltaPhase: u32,
453 stopDeltaPhase: u32,
454 deltaPhaseIncrement: u32,
455 dwellCount: u32,
456 arbitraryWaveform: *mut i16,
457 arbitraryWaveformSize: i32,
458 sweepType: PS6000_SWEEP_TYPE,
459 operation: PS6000_EXTRA_OPERATIONS,
460 indexMode: PS6000_INDEX_MODE,
461 shots: u32,
462 sweeps: u32,
463 triggerType: PS6000_SIGGEN_TRIG_TYPE,
464 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
465 extInThreshold: i16,
466 ) -> PICO_STATUS,
467 ::libloading::Error,
468 >,
469 pub ps6000SetSigGenBuiltIn: Result<
470 unsafe extern "C" fn(
471 handle: i16,
472 offsetVoltage: i32,
473 pkToPk: u32,
474 waveType: i16,
475 startFrequency: f32,
476 stopFrequency: f32,
477 increment: f32,
478 dwellTime: f32,
479 sweepType: PS6000_SWEEP_TYPE,
480 operation: PS6000_EXTRA_OPERATIONS,
481 shots: u32,
482 sweeps: u32,
483 triggerType: PS6000_SIGGEN_TRIG_TYPE,
484 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
485 extInThreshold: i16,
486 ) -> PICO_STATUS,
487 ::libloading::Error,
488 >,
489 pub ps6000SetSigGenBuiltInV2: Result<
490 unsafe extern "C" fn(
491 handle: i16,
492 offsetVoltage: i32,
493 pkToPk: u32,
494 waveType: i16,
495 startFrequency: f64,
496 stopFrequency: f64,
497 increment: f64,
498 dwellTime: f64,
499 sweepType: PS6000_SWEEP_TYPE,
500 operation: PS6000_EXTRA_OPERATIONS,
501 shots: u32,
502 sweeps: u32,
503 triggerType: PS6000_SIGGEN_TRIG_TYPE,
504 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
505 extInThreshold: i16,
506 ) -> PICO_STATUS,
507 ::libloading::Error,
508 >,
509 pub ps6000SetSigGenPropertiesArbitrary: Result<
510 unsafe extern "C" fn(
511 handle: i16,
512 offsetVoltage: i32,
513 pkToPk: u32,
514 startDeltaPhase: u32,
515 stopDeltaPhase: u32,
516 deltaPhaseIncrement: u32,
517 dwellCount: u32,
518 sweepType: PS6000_SWEEP_TYPE,
519 shots: u32,
520 sweeps: u32,
521 triggerType: PS6000_SIGGEN_TRIG_TYPE,
522 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
523 extInThreshold: i16,
524 ) -> PICO_STATUS,
525 ::libloading::Error,
526 >,
527 pub ps6000SetSigGenPropertiesBuiltIn: Result<
528 unsafe extern "C" fn(
529 handle: i16,
530 offsetVoltage: i32,
531 pkToPk: u32,
532 startFrequency: f64,
533 stopFrequency: f64,
534 increment: f64,
535 dwellTime: f64,
536 sweepType: PS6000_SWEEP_TYPE,
537 shots: u32,
538 sweeps: u32,
539 triggerType: PS6000_SIGGEN_TRIG_TYPE,
540 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
541 extInThreshold: i16,
542 ) -> PICO_STATUS,
543 ::libloading::Error,
544 >,
545 pub ps6000SigGenFrequencyToPhase: Result<
546 unsafe extern "C" fn(
547 handle: i16,
548 frequency: f64,
549 indexMode: PS6000_INDEX_MODE,
550 bufferLength: u32,
551 phase: *mut u32,
552 ) -> PICO_STATUS,
553 ::libloading::Error,
554 >,
555 pub ps6000SigGenArbitraryMinMaxValues: Result<
556 unsafe extern "C" fn(
557 handle: i16,
558 minArbitraryWaveformValue: *mut i16,
559 maxArbitraryWaveformValue: *mut i16,
560 minArbitraryWaveformSize: *mut u32,
561 maxArbitraryWaveformSize: *mut u32,
562 ) -> PICO_STATUS,
563 ::libloading::Error,
564 >,
565 pub ps6000SigGenSoftwareControl:
566 Result<unsafe extern "C" fn(handle: i16, state: i16) -> PICO_STATUS, ::libloading::Error>,
567 pub ps6000SetSimpleTrigger: Result<
568 unsafe extern "C" fn(
569 handle: i16,
570 enable: i16,
571 source: PS6000_CHANNEL,
572 threshold: i16,
573 direction: PS6000_THRESHOLD_DIRECTION,
574 delay: u32,
575 autoTrigger_ms: i16,
576 ) -> PICO_STATUS,
577 ::libloading::Error,
578 >,
579 pub ps6000SetEts: Result<
580 unsafe extern "C" fn(
581 handle: i16,
582 mode: PS6000_ETS_MODE,
583 etsCycles: i16,
584 etsInterleave: i16,
585 sampleTimePicoseconds: *mut i32,
586 ) -> PICO_STATUS,
587 ::libloading::Error,
588 >,
589 pub ps6000SetTriggerChannelProperties: Result<
590 unsafe extern "C" fn(
591 handle: i16,
592 channelProperties: *mut PS6000_TRIGGER_CHANNEL_PROPERTIES,
593 nChannelProperties: i16,
594 auxOutputEnable: i16,
595 autoTriggerMilliseconds: i32,
596 ) -> PICO_STATUS,
597 ::libloading::Error,
598 >,
599 pub ps6000SetTriggerChannelConditions: Result<
600 unsafe extern "C" fn(
601 handle: i16,
602 conditions: *mut PS6000_TRIGGER_CONDITIONS,
603 nConditions: i16,
604 ) -> PICO_STATUS,
605 ::libloading::Error,
606 >,
607 pub ps6000SetTriggerChannelDirections: Result<
608 unsafe extern "C" fn(
609 handle: i16,
610 channelA: PS6000_THRESHOLD_DIRECTION,
611 channelB: PS6000_THRESHOLD_DIRECTION,
612 channelC: PS6000_THRESHOLD_DIRECTION,
613 channelD: PS6000_THRESHOLD_DIRECTION,
614 ext: PS6000_THRESHOLD_DIRECTION,
615 aux: PS6000_THRESHOLD_DIRECTION,
616 ) -> PICO_STATUS,
617 ::libloading::Error,
618 >,
619 pub ps6000SetTriggerDelay:
620 Result<unsafe extern "C" fn(handle: i16, delay: u32) -> PICO_STATUS, ::libloading::Error>,
621 pub ps6000SetPulseWidthQualifier: Result<
622 unsafe extern "C" fn(
623 handle: i16,
624 conditions: *mut PS6000_PWQ_CONDITIONS,
625 nConditions: i16,
626 direction: PS6000_THRESHOLD_DIRECTION,
627 lower: u32,
628 upper: u32,
629 type_: PS6000_PULSE_WIDTH_TYPE,
630 ) -> PICO_STATUS,
631 ::libloading::Error,
632 >,
633 pub ps6000IsTriggerOrPulseWidthQualifierEnabled: Result<
634 unsafe extern "C" fn(
635 handle: i16,
636 triggerEnabled: *mut i16,
637 pulseWidthQualifierEnabled: *mut i16,
638 ) -> PICO_STATUS,
639 ::libloading::Error,
640 >,
641 pub ps6000GetTriggerTimeOffset: Result<
642 unsafe extern "C" fn(
643 handle: i16,
644 timeUpper: *mut u32,
645 timeLower: *mut u32,
646 timeUnits: *mut PS6000_TIME_UNITS,
647 segmentIndex: u32,
648 ) -> PICO_STATUS,
649 ::libloading::Error,
650 >,
651 pub ps6000GetTriggerTimeOffset64: Result<
652 unsafe extern "C" fn(
653 handle: i16,
654 time: *mut i64,
655 timeUnits: *mut PS6000_TIME_UNITS,
656 segmentIndex: u32,
657 ) -> PICO_STATUS,
658 ::libloading::Error,
659 >,
660 pub ps6000GetValuesTriggerTimeOffsetBulk: Result<
661 unsafe extern "C" fn(
662 handle: i16,
663 timesUpper: *mut u32,
664 timesLower: *mut u32,
665 timeUnits: *mut PS6000_TIME_UNITS,
666 fromSegmentIndex: u32,
667 toSegmentIndex: u32,
668 ) -> PICO_STATUS,
669 ::libloading::Error,
670 >,
671 pub ps6000GetValuesTriggerTimeOffsetBulk64: Result<
672 unsafe extern "C" fn(
673 handle: i16,
674 times: *mut i64,
675 timeUnits: *mut PS6000_TIME_UNITS,
676 fromSegmentIndex: u32,
677 toSegmentIndex: u32,
678 ) -> PICO_STATUS,
679 ::libloading::Error,
680 >,
681 pub ps6000SetDataBuffers: Result<
682 unsafe extern "C" fn(
683 handle: i16,
684 channel: PS6000_CHANNEL,
685 bufferMax: *mut i16,
686 bufferMin: *mut i16,
687 bufferLth: u32,
688 downSampleRatioMode: PS6000_RATIO_MODE,
689 ) -> PICO_STATUS,
690 ::libloading::Error,
691 >,
692 pub ps6000SetDataBuffer: Result<
693 unsafe extern "C" fn(
694 handle: i16,
695 channel: PS6000_CHANNEL,
696 buffer: *mut i16,
697 bufferLth: u32,
698 downSampleRatioMode: PS6000_RATIO_MODE,
699 ) -> PICO_STATUS,
700 ::libloading::Error,
701 >,
702 pub ps6000SetDataBufferBulk: Result<
703 unsafe extern "C" fn(
704 handle: i16,
705 channel: PS6000_CHANNEL,
706 buffer: *mut i16,
707 bufferLth: u32,
708 waveform: u32,
709 downSampleRatioMode: PS6000_RATIO_MODE,
710 ) -> PICO_STATUS,
711 ::libloading::Error,
712 >,
713 pub ps6000SetDataBuffersBulk: Result<
714 unsafe extern "C" fn(
715 handle: i16,
716 channel: PS6000_CHANNEL,
717 bufferMax: *mut i16,
718 bufferMin: *mut i16,
719 bufferLth: u32,
720 waveform: u32,
721 downSampleRatioMode: PS6000_RATIO_MODE,
722 ) -> PICO_STATUS,
723 ::libloading::Error,
724 >,
725 pub ps6000SetEtsTimeBuffer: Result<
726 unsafe extern "C" fn(handle: i16, buffer: *mut i64, bufferLth: u32) -> PICO_STATUS,
727 ::libloading::Error,
728 >,
729 pub ps6000SetEtsTimeBuffers: Result<
730 unsafe extern "C" fn(
731 handle: i16,
732 timeUpper: *mut u32,
733 timeLower: *mut u32,
734 bufferLth: u32,
735 ) -> PICO_STATUS,
736 ::libloading::Error,
737 >,
738 pub ps6000RunBlock: Result<
739 unsafe extern "C" fn(
740 handle: i16,
741 noOfPreTriggerSamples: u32,
742 noOfPostTriggerSamples: u32,
743 timebase: u32,
744 oversample: i16,
745 timeIndisposedMs: *mut i32,
746 segmentIndex: u32,
747 lpReady: ps6000BlockReady,
748 pParameter: *mut ::std::os::raw::c_void,
749 ) -> PICO_STATUS,
750 ::libloading::Error,
751 >,
752 pub ps6000IsReady: Result<
753 unsafe extern "C" fn(handle: i16, ready: *mut i16) -> PICO_STATUS,
754 ::libloading::Error,
755 >,
756 pub ps6000RunStreaming: Result<
757 unsafe extern "C" fn(
758 handle: i16,
759 sampleInterval: *mut u32,
760 sampleIntervalTimeUnits: PS6000_TIME_UNITS,
761 maxPreTriggerSamples: u32,
762 maxPostPreTriggerSamples: u32,
763 autoStop: i16,
764 downSampleRatio: u32,
765 downSampleRatioMode: PS6000_RATIO_MODE,
766 overviewBufferSize: u32,
767 ) -> PICO_STATUS,
768 ::libloading::Error,
769 >,
770 pub ps6000GetStreamingLatestValues: Result<
771 unsafe extern "C" fn(
772 handle: i16,
773 lpPs6000Ready: ps6000StreamingReady,
774 pParameter: *mut ::std::os::raw::c_void,
775 ) -> PICO_STATUS,
776 ::libloading::Error,
777 >,
778 pub ps6000NoOfStreamingValues: Result<
779 unsafe extern "C" fn(handle: i16, noOfValues: *mut u32) -> PICO_STATUS,
780 ::libloading::Error,
781 >,
782 pub ps6000GetMaxDownSampleRatio: Result<
783 unsafe extern "C" fn(
784 handle: i16,
785 noOfUnaggreatedSamples: u32,
786 maxDownSampleRatio: *mut u32,
787 downSampleRatioMode: PS6000_RATIO_MODE,
788 segmentIndex: u32,
789 ) -> PICO_STATUS,
790 ::libloading::Error,
791 >,
792 pub ps6000GetValues: Result<
793 unsafe extern "C" fn(
794 handle: i16,
795 startIndex: u32,
796 noOfSamples: *mut u32,
797 downSampleRatio: u32,
798 downSampleRatioMode: PS6000_RATIO_MODE,
799 segmentIndex: u32,
800 overflow: *mut i16,
801 ) -> PICO_STATUS,
802 ::libloading::Error,
803 >,
804 pub ps6000GetValuesBulk: Result<
805 unsafe extern "C" fn(
806 handle: i16,
807 noOfSamples: *mut u32,
808 fromSegmentIndex: u32,
809 toSegmentIndex: u32,
810 downSampleRatio: u32,
811 downSampleRatioMode: PS6000_RATIO_MODE,
812 overflow: *mut i16,
813 ) -> PICO_STATUS,
814 ::libloading::Error,
815 >,
816 pub ps6000GetValuesAsync: Result<
817 unsafe extern "C" fn(
818 handle: i16,
819 startIndex: u32,
820 noOfSamples: u32,
821 downSampleRatio: u32,
822 downSampleRatioMode: PS6000_RATIO_MODE,
823 segmentIndex: u32,
824 lpDataReady: *mut ::std::os::raw::c_void,
825 pParameter: *mut ::std::os::raw::c_void,
826 ) -> PICO_STATUS,
827 ::libloading::Error,
828 >,
829 pub ps6000GetValuesOverlapped: Result<
830 unsafe extern "C" fn(
831 handle: i16,
832 startIndex: u32,
833 noOfSamples: *mut u32,
834 downSampleRatio: u32,
835 downSampleRatioMode: PS6000_RATIO_MODE,
836 segmentIndex: u32,
837 overflow: *mut i16,
838 ) -> PICO_STATUS,
839 ::libloading::Error,
840 >,
841 pub ps6000GetValuesOverlappedBulk: Result<
842 unsafe extern "C" fn(
843 handle: i16,
844 startIndex: u32,
845 noOfSamples: *mut u32,
846 downSampleRatio: u32,
847 downSampleRatioMode: PS6000_RATIO_MODE,
848 fromSegmentIndex: u32,
849 toSegmentIndex: u32,
850 overflow: *mut i16,
851 ) -> PICO_STATUS,
852 ::libloading::Error,
853 >,
854 pub ps6000GetValuesBulkAsyc: Result<
855 unsafe extern "C" fn(
856 handle: i16,
857 startIndex: u32,
858 noOfSamples: *mut u32,
859 downSampleRatio: u32,
860 downSampleRatioMode: PS6000_RATIO_MODE,
861 fromSegmentIndex: u32,
862 toSegmentIndex: u32,
863 overflow: *mut i16,
864 ) -> PICO_STATUS,
865 ::libloading::Error,
866 >,
867 pub ps6000GetNoOfCaptures: Result<
868 unsafe extern "C" fn(handle: i16, nCaptures: *mut u32) -> PICO_STATUS,
869 ::libloading::Error,
870 >,
871 pub ps6000GetNoOfProcessedCaptures: Result<
872 unsafe extern "C" fn(handle: i16, nProcessedCaptures: *mut u32) -> PICO_STATUS,
873 ::libloading::Error,
874 >,
875 pub ps6000Stop: Result<unsafe extern "C" fn(handle: i16) -> PICO_STATUS, ::libloading::Error>,
876 pub ps6000SetNoOfCaptures: Result<
877 unsafe extern "C" fn(handle: i16, nCaptures: u32) -> PICO_STATUS,
878 ::libloading::Error,
879 >,
880 pub ps6000SetWaveformLimiter: Result<
881 unsafe extern "C" fn(handle: i16, nWaveformsPerSecond: u32) -> PICO_STATUS,
882 ::libloading::Error,
883 >,
884 pub ps6000GetTriggerInfoBulk: Result<
885 unsafe extern "C" fn(
886 handle: i16,
887 triggerInfo: *mut PS6000_TRIGGER_INFO,
888 fromSegmentIndex: u32,
889 toSegmentIndex: u32,
890 ) -> PICO_STATUS,
891 ::libloading::Error,
892 >,
893 pub ps6000EnumerateUnits: Result<
894 unsafe extern "C" fn(count: *mut i16, serials: *mut i8, serialLth: *mut i16) -> PICO_STATUS,
895 ::libloading::Error,
896 >,
897 pub ps6000SetExternalClock: Result<
898 unsafe extern "C" fn(
899 handle: i16,
900 frequency: PS6000_EXTERNAL_FREQUENCY,
901 threshold: i16,
902 ) -> PICO_STATUS,
903 ::libloading::Error,
904 >,
905 pub ps6000PingUnit:
906 Result<unsafe extern "C" fn(handle: i16) -> PICO_STATUS, ::libloading::Error>,
907 pub ps6000GetAnalogueOffset: Result<
908 unsafe extern "C" fn(
909 handle: i16,
910 range: PS6000_RANGE,
911 coupling: PS6000_COUPLING,
912 maximumVoltage: *mut f32,
913 minimumVoltage: *mut f32,
914 ) -> PICO_STATUS,
915 ::libloading::Error,
916 >,
917 pub ps6000QueryTemperatures: Result<
918 unsafe extern "C" fn(
919 handle: i16,
920 types: *mut PS6000_TEMPERATURES,
921 temperatures: *mut f32,
922 ) -> PICO_STATUS,
923 ::libloading::Error,
924 >,
925 pub ps6000QueryOutputEdgeDetect: Result<
926 unsafe extern "C" fn(handle: i16, state: *mut i16) -> PICO_STATUS,
927 ::libloading::Error,
928 >,
929 pub ps6000SetOutputEdgeDetect:
930 Result<unsafe extern "C" fn(handle: i16, state: i16) -> PICO_STATUS, ::libloading::Error>,
931}
932impl PS6000Loader {
933 pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
934 where
935 P: AsRef<::std::ffi::OsStr>,
936 {
937 let __library = ::libloading::Library::new(path)?;
938 let ps6000ApplyFix = __library.get(b"ps6000ApplyFix\0").map(|sym| *sym);
939 let ps6000OpenUnit = __library.get(b"ps6000OpenUnit\0").map(|sym| *sym);
940 let ps6000OpenUnitAsync = __library.get(b"ps6000OpenUnitAsync\0").map(|sym| *sym);
941 let ps6000OpenUnitProgress = __library.get(b"ps6000OpenUnitProgress\0").map(|sym| *sym);
942 let ps6000GetUnitInfo = __library.get(b"ps6000GetUnitInfo\0").map(|sym| *sym);
943 let ps6000FlashLed = __library.get(b"ps6000FlashLed\0").map(|sym| *sym);
944 let ps6000CloseUnit = __library.get(b"ps6000CloseUnit\0").map(|sym| *sym);
945 let ps6000MemorySegments = __library.get(b"ps6000MemorySegments\0").map(|sym| *sym);
946 let ps6000SetChannel = __library.get(b"ps6000SetChannel\0").map(|sym| *sym);
947 let ps6000GetTimebase = __library.get(b"ps6000GetTimebase\0").map(|sym| *sym);
948 let ps6000GetTimebase2 = __library.get(b"ps6000GetTimebase2\0").map(|sym| *sym);
949 let ps6000SetSigGenArbitrary = __library.get(b"ps6000SetSigGenArbitrary\0").map(|sym| *sym);
950 let ps6000SetSigGenBuiltIn = __library.get(b"ps6000SetSigGenBuiltIn\0").map(|sym| *sym);
951 let ps6000SetSigGenBuiltInV2 = __library.get(b"ps6000SetSigGenBuiltInV2\0").map(|sym| *sym);
952 let ps6000SetSigGenPropertiesArbitrary = __library
953 .get(b"ps6000SetSigGenPropertiesArbitrary\0")
954 .map(|sym| *sym);
955 let ps6000SetSigGenPropertiesBuiltIn = __library
956 .get(b"ps6000SetSigGenPropertiesBuiltIn\0")
957 .map(|sym| *sym);
958 let ps6000SigGenFrequencyToPhase = __library
959 .get(b"ps6000SigGenFrequencyToPhase\0")
960 .map(|sym| *sym);
961 let ps6000SigGenArbitraryMinMaxValues = __library
962 .get(b"ps6000SigGenArbitraryMinMaxValues\0")
963 .map(|sym| *sym);
964 let ps6000SigGenSoftwareControl = __library
965 .get(b"ps6000SigGenSoftwareControl\0")
966 .map(|sym| *sym);
967 let ps6000SetSimpleTrigger = __library.get(b"ps6000SetSimpleTrigger\0").map(|sym| *sym);
968 let ps6000SetEts = __library.get(b"ps6000SetEts\0").map(|sym| *sym);
969 let ps6000SetTriggerChannelProperties = __library
970 .get(b"ps6000SetTriggerChannelProperties\0")
971 .map(|sym| *sym);
972 let ps6000SetTriggerChannelConditions = __library
973 .get(b"ps6000SetTriggerChannelConditions\0")
974 .map(|sym| *sym);
975 let ps6000SetTriggerChannelDirections = __library
976 .get(b"ps6000SetTriggerChannelDirections\0")
977 .map(|sym| *sym);
978 let ps6000SetTriggerDelay = __library.get(b"ps6000SetTriggerDelay\0").map(|sym| *sym);
979 let ps6000SetPulseWidthQualifier = __library
980 .get(b"ps6000SetPulseWidthQualifier\0")
981 .map(|sym| *sym);
982 let ps6000IsTriggerOrPulseWidthQualifierEnabled = __library
983 .get(b"ps6000IsTriggerOrPulseWidthQualifierEnabled\0")
984 .map(|sym| *sym);
985 let ps6000GetTriggerTimeOffset = __library
986 .get(b"ps6000GetTriggerTimeOffset\0")
987 .map(|sym| *sym);
988 let ps6000GetTriggerTimeOffset64 = __library
989 .get(b"ps6000GetTriggerTimeOffset64\0")
990 .map(|sym| *sym);
991 let ps6000GetValuesTriggerTimeOffsetBulk = __library
992 .get(b"ps6000GetValuesTriggerTimeOffsetBulk\0")
993 .map(|sym| *sym);
994 let ps6000GetValuesTriggerTimeOffsetBulk64 = __library
995 .get(b"ps6000GetValuesTriggerTimeOffsetBulk64\0")
996 .map(|sym| *sym);
997 let ps6000SetDataBuffers = __library.get(b"ps6000SetDataBuffers\0").map(|sym| *sym);
998 let ps6000SetDataBuffer = __library.get(b"ps6000SetDataBuffer\0").map(|sym| *sym);
999 let ps6000SetDataBufferBulk = __library.get(b"ps6000SetDataBufferBulk\0").map(|sym| *sym);
1000 let ps6000SetDataBuffersBulk = __library.get(b"ps6000SetDataBuffersBulk\0").map(|sym| *sym);
1001 let ps6000SetEtsTimeBuffer = __library.get(b"ps6000SetEtsTimeBuffer\0").map(|sym| *sym);
1002 let ps6000SetEtsTimeBuffers = __library.get(b"ps6000SetEtsTimeBuffers\0").map(|sym| *sym);
1003 let ps6000RunBlock = __library.get(b"ps6000RunBlock\0").map(|sym| *sym);
1004 let ps6000IsReady = __library.get(b"ps6000IsReady\0").map(|sym| *sym);
1005 let ps6000RunStreaming = __library.get(b"ps6000RunStreaming\0").map(|sym| *sym);
1006 let ps6000GetStreamingLatestValues = __library
1007 .get(b"ps6000GetStreamingLatestValues\0")
1008 .map(|sym| *sym);
1009 let ps6000NoOfStreamingValues = __library
1010 .get(b"ps6000NoOfStreamingValues\0")
1011 .map(|sym| *sym);
1012 let ps6000GetMaxDownSampleRatio = __library
1013 .get(b"ps6000GetMaxDownSampleRatio\0")
1014 .map(|sym| *sym);
1015 let ps6000GetValues = __library.get(b"ps6000GetValues\0").map(|sym| *sym);
1016 let ps6000GetValuesBulk = __library.get(b"ps6000GetValuesBulk\0").map(|sym| *sym);
1017 let ps6000GetValuesAsync = __library.get(b"ps6000GetValuesAsync\0").map(|sym| *sym);
1018 let ps6000GetValuesOverlapped = __library
1019 .get(b"ps6000GetValuesOverlapped\0")
1020 .map(|sym| *sym);
1021 let ps6000GetValuesOverlappedBulk = __library
1022 .get(b"ps6000GetValuesOverlappedBulk\0")
1023 .map(|sym| *sym);
1024 let ps6000GetValuesBulkAsyc = __library.get(b"ps6000GetValuesBulkAsyc\0").map(|sym| *sym);
1025 let ps6000GetNoOfCaptures = __library.get(b"ps6000GetNoOfCaptures\0").map(|sym| *sym);
1026 let ps6000GetNoOfProcessedCaptures = __library
1027 .get(b"ps6000GetNoOfProcessedCaptures\0")
1028 .map(|sym| *sym);
1029 let ps6000Stop = __library.get(b"ps6000Stop\0").map(|sym| *sym);
1030 let ps6000SetNoOfCaptures = __library.get(b"ps6000SetNoOfCaptures\0").map(|sym| *sym);
1031 let ps6000SetWaveformLimiter = __library.get(b"ps6000SetWaveformLimiter\0").map(|sym| *sym);
1032 let ps6000GetTriggerInfoBulk = __library.get(b"ps6000GetTriggerInfoBulk\0").map(|sym| *sym);
1033 let ps6000EnumerateUnits = __library.get(b"ps6000EnumerateUnits\0").map(|sym| *sym);
1034 let ps6000SetExternalClock = __library.get(b"ps6000SetExternalClock\0").map(|sym| *sym);
1035 let ps6000PingUnit = __library.get(b"ps6000PingUnit\0").map(|sym| *sym);
1036 let ps6000GetAnalogueOffset = __library.get(b"ps6000GetAnalogueOffset\0").map(|sym| *sym);
1037 let ps6000QueryTemperatures = __library.get(b"ps6000QueryTemperatures\0").map(|sym| *sym);
1038 let ps6000QueryOutputEdgeDetect = __library
1039 .get(b"ps6000QueryOutputEdgeDetect\0")
1040 .map(|sym| *sym);
1041 let ps6000SetOutputEdgeDetect = __library
1042 .get(b"ps6000SetOutputEdgeDetect\0")
1043 .map(|sym| *sym);
1044 Ok(PS6000Loader {
1045 __library,
1046 ps6000ApplyFix,
1047 ps6000OpenUnit,
1048 ps6000OpenUnitAsync,
1049 ps6000OpenUnitProgress,
1050 ps6000GetUnitInfo,
1051 ps6000FlashLed,
1052 ps6000CloseUnit,
1053 ps6000MemorySegments,
1054 ps6000SetChannel,
1055 ps6000GetTimebase,
1056 ps6000GetTimebase2,
1057 ps6000SetSigGenArbitrary,
1058 ps6000SetSigGenBuiltIn,
1059 ps6000SetSigGenBuiltInV2,
1060 ps6000SetSigGenPropertiesArbitrary,
1061 ps6000SetSigGenPropertiesBuiltIn,
1062 ps6000SigGenFrequencyToPhase,
1063 ps6000SigGenArbitraryMinMaxValues,
1064 ps6000SigGenSoftwareControl,
1065 ps6000SetSimpleTrigger,
1066 ps6000SetEts,
1067 ps6000SetTriggerChannelProperties,
1068 ps6000SetTriggerChannelConditions,
1069 ps6000SetTriggerChannelDirections,
1070 ps6000SetTriggerDelay,
1071 ps6000SetPulseWidthQualifier,
1072 ps6000IsTriggerOrPulseWidthQualifierEnabled,
1073 ps6000GetTriggerTimeOffset,
1074 ps6000GetTriggerTimeOffset64,
1075 ps6000GetValuesTriggerTimeOffsetBulk,
1076 ps6000GetValuesTriggerTimeOffsetBulk64,
1077 ps6000SetDataBuffers,
1078 ps6000SetDataBuffer,
1079 ps6000SetDataBufferBulk,
1080 ps6000SetDataBuffersBulk,
1081 ps6000SetEtsTimeBuffer,
1082 ps6000SetEtsTimeBuffers,
1083 ps6000RunBlock,
1084 ps6000IsReady,
1085 ps6000RunStreaming,
1086 ps6000GetStreamingLatestValues,
1087 ps6000NoOfStreamingValues,
1088 ps6000GetMaxDownSampleRatio,
1089 ps6000GetValues,
1090 ps6000GetValuesBulk,
1091 ps6000GetValuesAsync,
1092 ps6000GetValuesOverlapped,
1093 ps6000GetValuesOverlappedBulk,
1094 ps6000GetValuesBulkAsyc,
1095 ps6000GetNoOfCaptures,
1096 ps6000GetNoOfProcessedCaptures,
1097 ps6000Stop,
1098 ps6000SetNoOfCaptures,
1099 ps6000SetWaveformLimiter,
1100 ps6000GetTriggerInfoBulk,
1101 ps6000EnumerateUnits,
1102 ps6000SetExternalClock,
1103 ps6000PingUnit,
1104 ps6000GetAnalogueOffset,
1105 ps6000QueryTemperatures,
1106 ps6000QueryOutputEdgeDetect,
1107 ps6000SetOutputEdgeDetect,
1108 })
1109 }
1110 pub unsafe fn ps6000ApplyFix(&self, a: u32, b: u16) {
1111 let sym = self
1112 .ps6000ApplyFix
1113 .as_ref()
1114 .expect("Expected function, got error.");
1115 (sym)(a, b)
1116 }
1117 pub unsafe fn ps6000OpenUnit(&self, handle: *mut i16, serial: *mut i8) -> PICO_STATUS {
1118 let sym = self
1119 .ps6000OpenUnit
1120 .as_ref()
1121 .expect("Expected function, got error.");
1122 (sym)(handle, serial)
1123 }
1124 pub unsafe fn ps6000OpenUnitAsync(&self, status: *mut i16, serial: *mut i8) -> PICO_STATUS {
1125 let sym = self
1126 .ps6000OpenUnitAsync
1127 .as_ref()
1128 .expect("Expected function, got error.");
1129 (sym)(status, serial)
1130 }
1131 pub unsafe fn ps6000OpenUnitProgress(
1132 &self,
1133 handle: *mut i16,
1134 progressPercent: *mut i16,
1135 complete: *mut i16,
1136 ) -> PICO_STATUS {
1137 let sym = self
1138 .ps6000OpenUnitProgress
1139 .as_ref()
1140 .expect("Expected function, got error.");
1141 (sym)(handle, progressPercent, complete)
1142 }
1143 pub unsafe fn ps6000GetUnitInfo(
1144 &self,
1145 handle: i16,
1146 string: *mut i8,
1147 stringLength: i16,
1148 requiredSize: *mut i16,
1149 info: PICO_INFO,
1150 ) -> PICO_STATUS {
1151 let sym = self
1152 .ps6000GetUnitInfo
1153 .as_ref()
1154 .expect("Expected function, got error.");
1155 (sym)(handle, string, stringLength, requiredSize, info)
1156 }
1157 pub unsafe fn ps6000FlashLed(&self, handle: i16, start: i16) -> PICO_STATUS {
1158 let sym = self
1159 .ps6000FlashLed
1160 .as_ref()
1161 .expect("Expected function, got error.");
1162 (sym)(handle, start)
1163 }
1164 pub unsafe fn ps6000CloseUnit(&self, handle: i16) -> PICO_STATUS {
1165 let sym = self
1166 .ps6000CloseUnit
1167 .as_ref()
1168 .expect("Expected function, got error.");
1169 (sym)(handle)
1170 }
1171 pub unsafe fn ps6000MemorySegments(
1172 &self,
1173 handle: i16,
1174 nSegments: u32,
1175 nMaxSamples: *mut u32,
1176 ) -> PICO_STATUS {
1177 let sym = self
1178 .ps6000MemorySegments
1179 .as_ref()
1180 .expect("Expected function, got error.");
1181 (sym)(handle, nSegments, nMaxSamples)
1182 }
1183 pub unsafe fn ps6000SetChannel(
1184 &self,
1185 handle: i16,
1186 channel: PS6000_CHANNEL,
1187 enabled: i16,
1188 type_: PS6000_COUPLING,
1189 range: PS6000_RANGE,
1190 analogueOffset: f32,
1191 bandwidth: PS6000_BANDWIDTH_LIMITER,
1192 ) -> PICO_STATUS {
1193 let sym = self
1194 .ps6000SetChannel
1195 .as_ref()
1196 .expect("Expected function, got error.");
1197 (sym)(
1198 handle,
1199 channel,
1200 enabled,
1201 type_,
1202 range,
1203 analogueOffset,
1204 bandwidth,
1205 )
1206 }
1207 pub unsafe fn ps6000GetTimebase(
1208 &self,
1209 handle: i16,
1210 timebase: u32,
1211 noSamples: u32,
1212 timeIntervalNanoseconds: *mut i32,
1213 oversample: i16,
1214 maxSamples: *mut u32,
1215 segmentIndex: u32,
1216 ) -> PICO_STATUS {
1217 let sym = self
1218 .ps6000GetTimebase
1219 .as_ref()
1220 .expect("Expected function, got error.");
1221 (sym)(
1222 handle,
1223 timebase,
1224 noSamples,
1225 timeIntervalNanoseconds,
1226 oversample,
1227 maxSamples,
1228 segmentIndex,
1229 )
1230 }
1231 pub unsafe fn ps6000GetTimebase2(
1232 &self,
1233 handle: i16,
1234 timebase: u32,
1235 noSamples: u32,
1236 timeIntervalNanoseconds: *mut f32,
1237 oversample: i16,
1238 maxSamples: *mut u32,
1239 segmentIndex: u32,
1240 ) -> PICO_STATUS {
1241 let sym = self
1242 .ps6000GetTimebase2
1243 .as_ref()
1244 .expect("Expected function, got error.");
1245 (sym)(
1246 handle,
1247 timebase,
1248 noSamples,
1249 timeIntervalNanoseconds,
1250 oversample,
1251 maxSamples,
1252 segmentIndex,
1253 )
1254 }
1255 pub unsafe fn ps6000SetSigGenArbitrary(
1256 &self,
1257 handle: i16,
1258 offsetVoltage: i32,
1259 pkToPk: u32,
1260 startDeltaPhase: u32,
1261 stopDeltaPhase: u32,
1262 deltaPhaseIncrement: u32,
1263 dwellCount: u32,
1264 arbitraryWaveform: *mut i16,
1265 arbitraryWaveformSize: i32,
1266 sweepType: PS6000_SWEEP_TYPE,
1267 operation: PS6000_EXTRA_OPERATIONS,
1268 indexMode: PS6000_INDEX_MODE,
1269 shots: u32,
1270 sweeps: u32,
1271 triggerType: PS6000_SIGGEN_TRIG_TYPE,
1272 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
1273 extInThreshold: i16,
1274 ) -> PICO_STATUS {
1275 let sym = self
1276 .ps6000SetSigGenArbitrary
1277 .as_ref()
1278 .expect("Expected function, got error.");
1279 (sym)(
1280 handle,
1281 offsetVoltage,
1282 pkToPk,
1283 startDeltaPhase,
1284 stopDeltaPhase,
1285 deltaPhaseIncrement,
1286 dwellCount,
1287 arbitraryWaveform,
1288 arbitraryWaveformSize,
1289 sweepType,
1290 operation,
1291 indexMode,
1292 shots,
1293 sweeps,
1294 triggerType,
1295 triggerSource,
1296 extInThreshold,
1297 )
1298 }
1299 pub unsafe fn ps6000SetSigGenBuiltIn(
1300 &self,
1301 handle: i16,
1302 offsetVoltage: i32,
1303 pkToPk: u32,
1304 waveType: i16,
1305 startFrequency: f32,
1306 stopFrequency: f32,
1307 increment: f32,
1308 dwellTime: f32,
1309 sweepType: PS6000_SWEEP_TYPE,
1310 operation: PS6000_EXTRA_OPERATIONS,
1311 shots: u32,
1312 sweeps: u32,
1313 triggerType: PS6000_SIGGEN_TRIG_TYPE,
1314 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
1315 extInThreshold: i16,
1316 ) -> PICO_STATUS {
1317 let sym = self
1318 .ps6000SetSigGenBuiltIn
1319 .as_ref()
1320 .expect("Expected function, got error.");
1321 (sym)(
1322 handle,
1323 offsetVoltage,
1324 pkToPk,
1325 waveType,
1326 startFrequency,
1327 stopFrequency,
1328 increment,
1329 dwellTime,
1330 sweepType,
1331 operation,
1332 shots,
1333 sweeps,
1334 triggerType,
1335 triggerSource,
1336 extInThreshold,
1337 )
1338 }
1339 pub unsafe fn ps6000SetSigGenBuiltInV2(
1340 &self,
1341 handle: i16,
1342 offsetVoltage: i32,
1343 pkToPk: u32,
1344 waveType: i16,
1345 startFrequency: f64,
1346 stopFrequency: f64,
1347 increment: f64,
1348 dwellTime: f64,
1349 sweepType: PS6000_SWEEP_TYPE,
1350 operation: PS6000_EXTRA_OPERATIONS,
1351 shots: u32,
1352 sweeps: u32,
1353 triggerType: PS6000_SIGGEN_TRIG_TYPE,
1354 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
1355 extInThreshold: i16,
1356 ) -> PICO_STATUS {
1357 let sym = self
1358 .ps6000SetSigGenBuiltInV2
1359 .as_ref()
1360 .expect("Expected function, got error.");
1361 (sym)(
1362 handle,
1363 offsetVoltage,
1364 pkToPk,
1365 waveType,
1366 startFrequency,
1367 stopFrequency,
1368 increment,
1369 dwellTime,
1370 sweepType,
1371 operation,
1372 shots,
1373 sweeps,
1374 triggerType,
1375 triggerSource,
1376 extInThreshold,
1377 )
1378 }
1379 pub unsafe fn ps6000SetSigGenPropertiesArbitrary(
1380 &self,
1381 handle: i16,
1382 offsetVoltage: i32,
1383 pkToPk: u32,
1384 startDeltaPhase: u32,
1385 stopDeltaPhase: u32,
1386 deltaPhaseIncrement: u32,
1387 dwellCount: u32,
1388 sweepType: PS6000_SWEEP_TYPE,
1389 shots: u32,
1390 sweeps: u32,
1391 triggerType: PS6000_SIGGEN_TRIG_TYPE,
1392 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
1393 extInThreshold: i16,
1394 ) -> PICO_STATUS {
1395 let sym = self
1396 .ps6000SetSigGenPropertiesArbitrary
1397 .as_ref()
1398 .expect("Expected function, got error.");
1399 (sym)(
1400 handle,
1401 offsetVoltage,
1402 pkToPk,
1403 startDeltaPhase,
1404 stopDeltaPhase,
1405 deltaPhaseIncrement,
1406 dwellCount,
1407 sweepType,
1408 shots,
1409 sweeps,
1410 triggerType,
1411 triggerSource,
1412 extInThreshold,
1413 )
1414 }
1415 pub unsafe fn ps6000SetSigGenPropertiesBuiltIn(
1416 &self,
1417 handle: i16,
1418 offsetVoltage: i32,
1419 pkToPk: u32,
1420 startFrequency: f64,
1421 stopFrequency: f64,
1422 increment: f64,
1423 dwellTime: f64,
1424 sweepType: PS6000_SWEEP_TYPE,
1425 shots: u32,
1426 sweeps: u32,
1427 triggerType: PS6000_SIGGEN_TRIG_TYPE,
1428 triggerSource: PS6000_SIGGEN_TRIG_SOURCE,
1429 extInThreshold: i16,
1430 ) -> PICO_STATUS {
1431 let sym = self
1432 .ps6000SetSigGenPropertiesBuiltIn
1433 .as_ref()
1434 .expect("Expected function, got error.");
1435 (sym)(
1436 handle,
1437 offsetVoltage,
1438 pkToPk,
1439 startFrequency,
1440 stopFrequency,
1441 increment,
1442 dwellTime,
1443 sweepType,
1444 shots,
1445 sweeps,
1446 triggerType,
1447 triggerSource,
1448 extInThreshold,
1449 )
1450 }
1451 pub unsafe fn ps6000SigGenFrequencyToPhase(
1452 &self,
1453 handle: i16,
1454 frequency: f64,
1455 indexMode: PS6000_INDEX_MODE,
1456 bufferLength: u32,
1457 phase: *mut u32,
1458 ) -> PICO_STATUS {
1459 let sym = self
1460 .ps6000SigGenFrequencyToPhase
1461 .as_ref()
1462 .expect("Expected function, got error.");
1463 (sym)(handle, frequency, indexMode, bufferLength, phase)
1464 }
1465 pub unsafe fn ps6000SigGenArbitraryMinMaxValues(
1466 &self,
1467 handle: i16,
1468 minArbitraryWaveformValue: *mut i16,
1469 maxArbitraryWaveformValue: *mut i16,
1470 minArbitraryWaveformSize: *mut u32,
1471 maxArbitraryWaveformSize: *mut u32,
1472 ) -> PICO_STATUS {
1473 let sym = self
1474 .ps6000SigGenArbitraryMinMaxValues
1475 .as_ref()
1476 .expect("Expected function, got error.");
1477 (sym)(
1478 handle,
1479 minArbitraryWaveformValue,
1480 maxArbitraryWaveformValue,
1481 minArbitraryWaveformSize,
1482 maxArbitraryWaveformSize,
1483 )
1484 }
1485 pub unsafe fn ps6000SigGenSoftwareControl(&self, handle: i16, state: i16) -> PICO_STATUS {
1486 let sym = self
1487 .ps6000SigGenSoftwareControl
1488 .as_ref()
1489 .expect("Expected function, got error.");
1490 (sym)(handle, state)
1491 }
1492 pub unsafe fn ps6000SetSimpleTrigger(
1493 &self,
1494 handle: i16,
1495 enable: i16,
1496 source: PS6000_CHANNEL,
1497 threshold: i16,
1498 direction: PS6000_THRESHOLD_DIRECTION,
1499 delay: u32,
1500 autoTrigger_ms: i16,
1501 ) -> PICO_STATUS {
1502 let sym = self
1503 .ps6000SetSimpleTrigger
1504 .as_ref()
1505 .expect("Expected function, got error.");
1506 (sym)(
1507 handle,
1508 enable,
1509 source,
1510 threshold,
1511 direction,
1512 delay,
1513 autoTrigger_ms,
1514 )
1515 }
1516 pub unsafe fn ps6000SetEts(
1517 &self,
1518 handle: i16,
1519 mode: PS6000_ETS_MODE,
1520 etsCycles: i16,
1521 etsInterleave: i16,
1522 sampleTimePicoseconds: *mut i32,
1523 ) -> PICO_STATUS {
1524 let sym = self
1525 .ps6000SetEts
1526 .as_ref()
1527 .expect("Expected function, got error.");
1528 (sym)(
1529 handle,
1530 mode,
1531 etsCycles,
1532 etsInterleave,
1533 sampleTimePicoseconds,
1534 )
1535 }
1536 pub unsafe fn ps6000SetTriggerChannelProperties(
1537 &self,
1538 handle: i16,
1539 channelProperties: *mut PS6000_TRIGGER_CHANNEL_PROPERTIES,
1540 nChannelProperties: i16,
1541 auxOutputEnable: i16,
1542 autoTriggerMilliseconds: i32,
1543 ) -> PICO_STATUS {
1544 let sym = self
1545 .ps6000SetTriggerChannelProperties
1546 .as_ref()
1547 .expect("Expected function, got error.");
1548 (sym)(
1549 handle,
1550 channelProperties,
1551 nChannelProperties,
1552 auxOutputEnable,
1553 autoTriggerMilliseconds,
1554 )
1555 }
1556 pub unsafe fn ps6000SetTriggerChannelConditions(
1557 &self,
1558 handle: i16,
1559 conditions: *mut PS6000_TRIGGER_CONDITIONS,
1560 nConditions: i16,
1561 ) -> PICO_STATUS {
1562 let sym = self
1563 .ps6000SetTriggerChannelConditions
1564 .as_ref()
1565 .expect("Expected function, got error.");
1566 (sym)(handle, conditions, nConditions)
1567 }
1568 pub unsafe fn ps6000SetTriggerChannelDirections(
1569 &self,
1570 handle: i16,
1571 channelA: PS6000_THRESHOLD_DIRECTION,
1572 channelB: PS6000_THRESHOLD_DIRECTION,
1573 channelC: PS6000_THRESHOLD_DIRECTION,
1574 channelD: PS6000_THRESHOLD_DIRECTION,
1575 ext: PS6000_THRESHOLD_DIRECTION,
1576 aux: PS6000_THRESHOLD_DIRECTION,
1577 ) -> PICO_STATUS {
1578 let sym = self
1579 .ps6000SetTriggerChannelDirections
1580 .as_ref()
1581 .expect("Expected function, got error.");
1582 (sym)(handle, channelA, channelB, channelC, channelD, ext, aux)
1583 }
1584 pub unsafe fn ps6000SetTriggerDelay(&self, handle: i16, delay: u32) -> PICO_STATUS {
1585 let sym = self
1586 .ps6000SetTriggerDelay
1587 .as_ref()
1588 .expect("Expected function, got error.");
1589 (sym)(handle, delay)
1590 }
1591 pub unsafe fn ps6000SetPulseWidthQualifier(
1592 &self,
1593 handle: i16,
1594 conditions: *mut PS6000_PWQ_CONDITIONS,
1595 nConditions: i16,
1596 direction: PS6000_THRESHOLD_DIRECTION,
1597 lower: u32,
1598 upper: u32,
1599 type_: PS6000_PULSE_WIDTH_TYPE,
1600 ) -> PICO_STATUS {
1601 let sym = self
1602 .ps6000SetPulseWidthQualifier
1603 .as_ref()
1604 .expect("Expected function, got error.");
1605 (sym)(
1606 handle,
1607 conditions,
1608 nConditions,
1609 direction,
1610 lower,
1611 upper,
1612 type_,
1613 )
1614 }
1615 pub unsafe fn ps6000IsTriggerOrPulseWidthQualifierEnabled(
1616 &self,
1617 handle: i16,
1618 triggerEnabled: *mut i16,
1619 pulseWidthQualifierEnabled: *mut i16,
1620 ) -> PICO_STATUS {
1621 let sym = self
1622 .ps6000IsTriggerOrPulseWidthQualifierEnabled
1623 .as_ref()
1624 .expect("Expected function, got error.");
1625 (sym)(handle, triggerEnabled, pulseWidthQualifierEnabled)
1626 }
1627 pub unsafe fn ps6000GetTriggerTimeOffset(
1628 &self,
1629 handle: i16,
1630 timeUpper: *mut u32,
1631 timeLower: *mut u32,
1632 timeUnits: *mut PS6000_TIME_UNITS,
1633 segmentIndex: u32,
1634 ) -> PICO_STATUS {
1635 let sym = self
1636 .ps6000GetTriggerTimeOffset
1637 .as_ref()
1638 .expect("Expected function, got error.");
1639 (sym)(handle, timeUpper, timeLower, timeUnits, segmentIndex)
1640 }
1641 pub unsafe fn ps6000GetTriggerTimeOffset64(
1642 &self,
1643 handle: i16,
1644 time: *mut i64,
1645 timeUnits: *mut PS6000_TIME_UNITS,
1646 segmentIndex: u32,
1647 ) -> PICO_STATUS {
1648 let sym = self
1649 .ps6000GetTriggerTimeOffset64
1650 .as_ref()
1651 .expect("Expected function, got error.");
1652 (sym)(handle, time, timeUnits, segmentIndex)
1653 }
1654 pub unsafe fn ps6000GetValuesTriggerTimeOffsetBulk(
1655 &self,
1656 handle: i16,
1657 timesUpper: *mut u32,
1658 timesLower: *mut u32,
1659 timeUnits: *mut PS6000_TIME_UNITS,
1660 fromSegmentIndex: u32,
1661 toSegmentIndex: u32,
1662 ) -> PICO_STATUS {
1663 let sym = self
1664 .ps6000GetValuesTriggerTimeOffsetBulk
1665 .as_ref()
1666 .expect("Expected function, got error.");
1667 (sym)(
1668 handle,
1669 timesUpper,
1670 timesLower,
1671 timeUnits,
1672 fromSegmentIndex,
1673 toSegmentIndex,
1674 )
1675 }
1676 pub unsafe fn ps6000GetValuesTriggerTimeOffsetBulk64(
1677 &self,
1678 handle: i16,
1679 times: *mut i64,
1680 timeUnits: *mut PS6000_TIME_UNITS,
1681 fromSegmentIndex: u32,
1682 toSegmentIndex: u32,
1683 ) -> PICO_STATUS {
1684 let sym = self
1685 .ps6000GetValuesTriggerTimeOffsetBulk64
1686 .as_ref()
1687 .expect("Expected function, got error.");
1688 (sym)(handle, times, timeUnits, fromSegmentIndex, toSegmentIndex)
1689 }
1690 pub unsafe fn ps6000SetDataBuffers(
1691 &self,
1692 handle: i16,
1693 channel: PS6000_CHANNEL,
1694 bufferMax: *mut i16,
1695 bufferMin: *mut i16,
1696 bufferLth: u32,
1697 downSampleRatioMode: PS6000_RATIO_MODE,
1698 ) -> PICO_STATUS {
1699 let sym = self
1700 .ps6000SetDataBuffers
1701 .as_ref()
1702 .expect("Expected function, got error.");
1703 (sym)(
1704 handle,
1705 channel,
1706 bufferMax,
1707 bufferMin,
1708 bufferLth,
1709 downSampleRatioMode,
1710 )
1711 }
1712 pub unsafe fn ps6000SetDataBuffer(
1713 &self,
1714 handle: i16,
1715 channel: PS6000_CHANNEL,
1716 buffer: *mut i16,
1717 bufferLth: u32,
1718 downSampleRatioMode: PS6000_RATIO_MODE,
1719 ) -> PICO_STATUS {
1720 let sym = self
1721 .ps6000SetDataBuffer
1722 .as_ref()
1723 .expect("Expected function, got error.");
1724 (sym)(handle, channel, buffer, bufferLth, downSampleRatioMode)
1725 }
1726 pub unsafe fn ps6000SetDataBufferBulk(
1727 &self,
1728 handle: i16,
1729 channel: PS6000_CHANNEL,
1730 buffer: *mut i16,
1731 bufferLth: u32,
1732 waveform: u32,
1733 downSampleRatioMode: PS6000_RATIO_MODE,
1734 ) -> PICO_STATUS {
1735 let sym = self
1736 .ps6000SetDataBufferBulk
1737 .as_ref()
1738 .expect("Expected function, got error.");
1739 (sym)(
1740 handle,
1741 channel,
1742 buffer,
1743 bufferLth,
1744 waveform,
1745 downSampleRatioMode,
1746 )
1747 }
1748 pub unsafe fn ps6000SetDataBuffersBulk(
1749 &self,
1750 handle: i16,
1751 channel: PS6000_CHANNEL,
1752 bufferMax: *mut i16,
1753 bufferMin: *mut i16,
1754 bufferLth: u32,
1755 waveform: u32,
1756 downSampleRatioMode: PS6000_RATIO_MODE,
1757 ) -> PICO_STATUS {
1758 let sym = self
1759 .ps6000SetDataBuffersBulk
1760 .as_ref()
1761 .expect("Expected function, got error.");
1762 (sym)(
1763 handle,
1764 channel,
1765 bufferMax,
1766 bufferMin,
1767 bufferLth,
1768 waveform,
1769 downSampleRatioMode,
1770 )
1771 }
1772 pub unsafe fn ps6000SetEtsTimeBuffer(
1773 &self,
1774 handle: i16,
1775 buffer: *mut i64,
1776 bufferLth: u32,
1777 ) -> PICO_STATUS {
1778 let sym = self
1779 .ps6000SetEtsTimeBuffer
1780 .as_ref()
1781 .expect("Expected function, got error.");
1782 (sym)(handle, buffer, bufferLth)
1783 }
1784 pub unsafe fn ps6000SetEtsTimeBuffers(
1785 &self,
1786 handle: i16,
1787 timeUpper: *mut u32,
1788 timeLower: *mut u32,
1789 bufferLth: u32,
1790 ) -> PICO_STATUS {
1791 let sym = self
1792 .ps6000SetEtsTimeBuffers
1793 .as_ref()
1794 .expect("Expected function, got error.");
1795 (sym)(handle, timeUpper, timeLower, bufferLth)
1796 }
1797 pub unsafe fn ps6000RunBlock(
1798 &self,
1799 handle: i16,
1800 noOfPreTriggerSamples: u32,
1801 noOfPostTriggerSamples: u32,
1802 timebase: u32,
1803 oversample: i16,
1804 timeIndisposedMs: *mut i32,
1805 segmentIndex: u32,
1806 lpReady: ps6000BlockReady,
1807 pParameter: *mut ::std::os::raw::c_void,
1808 ) -> PICO_STATUS {
1809 let sym = self
1810 .ps6000RunBlock
1811 .as_ref()
1812 .expect("Expected function, got error.");
1813 (sym)(
1814 handle,
1815 noOfPreTriggerSamples,
1816 noOfPostTriggerSamples,
1817 timebase,
1818 oversample,
1819 timeIndisposedMs,
1820 segmentIndex,
1821 lpReady,
1822 pParameter,
1823 )
1824 }
1825 pub unsafe fn ps6000IsReady(&self, handle: i16, ready: *mut i16) -> PICO_STATUS {
1826 let sym = self
1827 .ps6000IsReady
1828 .as_ref()
1829 .expect("Expected function, got error.");
1830 (sym)(handle, ready)
1831 }
1832 pub unsafe fn ps6000RunStreaming(
1833 &self,
1834 handle: i16,
1835 sampleInterval: *mut u32,
1836 sampleIntervalTimeUnits: PS6000_TIME_UNITS,
1837 maxPreTriggerSamples: u32,
1838 maxPostPreTriggerSamples: u32,
1839 autoStop: i16,
1840 downSampleRatio: u32,
1841 downSampleRatioMode: PS6000_RATIO_MODE,
1842 overviewBufferSize: u32,
1843 ) -> PICO_STATUS {
1844 let sym = self
1845 .ps6000RunStreaming
1846 .as_ref()
1847 .expect("Expected function, got error.");
1848 (sym)(
1849 handle,
1850 sampleInterval,
1851 sampleIntervalTimeUnits,
1852 maxPreTriggerSamples,
1853 maxPostPreTriggerSamples,
1854 autoStop,
1855 downSampleRatio,
1856 downSampleRatioMode,
1857 overviewBufferSize,
1858 )
1859 }
1860 pub unsafe fn ps6000GetStreamingLatestValues(
1861 &self,
1862 handle: i16,
1863 lpPs6000Ready: ps6000StreamingReady,
1864 pParameter: *mut ::std::os::raw::c_void,
1865 ) -> PICO_STATUS {
1866 let sym = self
1867 .ps6000GetStreamingLatestValues
1868 .as_ref()
1869 .expect("Expected function, got error.");
1870 (sym)(handle, lpPs6000Ready, pParameter)
1871 }
1872 pub unsafe fn ps6000NoOfStreamingValues(
1873 &self,
1874 handle: i16,
1875 noOfValues: *mut u32,
1876 ) -> PICO_STATUS {
1877 let sym = self
1878 .ps6000NoOfStreamingValues
1879 .as_ref()
1880 .expect("Expected function, got error.");
1881 (sym)(handle, noOfValues)
1882 }
1883 pub unsafe fn ps6000GetMaxDownSampleRatio(
1884 &self,
1885 handle: i16,
1886 noOfUnaggreatedSamples: u32,
1887 maxDownSampleRatio: *mut u32,
1888 downSampleRatioMode: PS6000_RATIO_MODE,
1889 segmentIndex: u32,
1890 ) -> PICO_STATUS {
1891 let sym = self
1892 .ps6000GetMaxDownSampleRatio
1893 .as_ref()
1894 .expect("Expected function, got error.");
1895 (sym)(
1896 handle,
1897 noOfUnaggreatedSamples,
1898 maxDownSampleRatio,
1899 downSampleRatioMode,
1900 segmentIndex,
1901 )
1902 }
1903 pub unsafe fn ps6000GetValues(
1904 &self,
1905 handle: i16,
1906 startIndex: u32,
1907 noOfSamples: *mut u32,
1908 downSampleRatio: u32,
1909 downSampleRatioMode: PS6000_RATIO_MODE,
1910 segmentIndex: u32,
1911 overflow: *mut i16,
1912 ) -> PICO_STATUS {
1913 let sym = self
1914 .ps6000GetValues
1915 .as_ref()
1916 .expect("Expected function, got error.");
1917 (sym)(
1918 handle,
1919 startIndex,
1920 noOfSamples,
1921 downSampleRatio,
1922 downSampleRatioMode,
1923 segmentIndex,
1924 overflow,
1925 )
1926 }
1927 pub unsafe fn ps6000GetValuesBulk(
1928 &self,
1929 handle: i16,
1930 noOfSamples: *mut u32,
1931 fromSegmentIndex: u32,
1932 toSegmentIndex: u32,
1933 downSampleRatio: u32,
1934 downSampleRatioMode: PS6000_RATIO_MODE,
1935 overflow: *mut i16,
1936 ) -> PICO_STATUS {
1937 let sym = self
1938 .ps6000GetValuesBulk
1939 .as_ref()
1940 .expect("Expected function, got error.");
1941 (sym)(
1942 handle,
1943 noOfSamples,
1944 fromSegmentIndex,
1945 toSegmentIndex,
1946 downSampleRatio,
1947 downSampleRatioMode,
1948 overflow,
1949 )
1950 }
1951 pub unsafe fn ps6000GetValuesAsync(
1952 &self,
1953 handle: i16,
1954 startIndex: u32,
1955 noOfSamples: u32,
1956 downSampleRatio: u32,
1957 downSampleRatioMode: PS6000_RATIO_MODE,
1958 segmentIndex: u32,
1959 lpDataReady: *mut ::std::os::raw::c_void,
1960 pParameter: *mut ::std::os::raw::c_void,
1961 ) -> PICO_STATUS {
1962 let sym = self
1963 .ps6000GetValuesAsync
1964 .as_ref()
1965 .expect("Expected function, got error.");
1966 (sym)(
1967 handle,
1968 startIndex,
1969 noOfSamples,
1970 downSampleRatio,
1971 downSampleRatioMode,
1972 segmentIndex,
1973 lpDataReady,
1974 pParameter,
1975 )
1976 }
1977 pub unsafe fn ps6000GetValuesOverlapped(
1978 &self,
1979 handle: i16,
1980 startIndex: u32,
1981 noOfSamples: *mut u32,
1982 downSampleRatio: u32,
1983 downSampleRatioMode: PS6000_RATIO_MODE,
1984 segmentIndex: u32,
1985 overflow: *mut i16,
1986 ) -> PICO_STATUS {
1987 let sym = self
1988 .ps6000GetValuesOverlapped
1989 .as_ref()
1990 .expect("Expected function, got error.");
1991 (sym)(
1992 handle,
1993 startIndex,
1994 noOfSamples,
1995 downSampleRatio,
1996 downSampleRatioMode,
1997 segmentIndex,
1998 overflow,
1999 )
2000 }
2001 pub unsafe fn ps6000GetValuesOverlappedBulk(
2002 &self,
2003 handle: i16,
2004 startIndex: u32,
2005 noOfSamples: *mut u32,
2006 downSampleRatio: u32,
2007 downSampleRatioMode: PS6000_RATIO_MODE,
2008 fromSegmentIndex: u32,
2009 toSegmentIndex: u32,
2010 overflow: *mut i16,
2011 ) -> PICO_STATUS {
2012 let sym = self
2013 .ps6000GetValuesOverlappedBulk
2014 .as_ref()
2015 .expect("Expected function, got error.");
2016 (sym)(
2017 handle,
2018 startIndex,
2019 noOfSamples,
2020 downSampleRatio,
2021 downSampleRatioMode,
2022 fromSegmentIndex,
2023 toSegmentIndex,
2024 overflow,
2025 )
2026 }
2027 pub unsafe fn ps6000GetValuesBulkAsyc(
2028 &self,
2029 handle: i16,
2030 startIndex: u32,
2031 noOfSamples: *mut u32,
2032 downSampleRatio: u32,
2033 downSampleRatioMode: PS6000_RATIO_MODE,
2034 fromSegmentIndex: u32,
2035 toSegmentIndex: u32,
2036 overflow: *mut i16,
2037 ) -> PICO_STATUS {
2038 let sym = self
2039 .ps6000GetValuesBulkAsyc
2040 .as_ref()
2041 .expect("Expected function, got error.");
2042 (sym)(
2043 handle,
2044 startIndex,
2045 noOfSamples,
2046 downSampleRatio,
2047 downSampleRatioMode,
2048 fromSegmentIndex,
2049 toSegmentIndex,
2050 overflow,
2051 )
2052 }
2053 pub unsafe fn ps6000GetNoOfCaptures(&self, handle: i16, nCaptures: *mut u32) -> PICO_STATUS {
2054 let sym = self
2055 .ps6000GetNoOfCaptures
2056 .as_ref()
2057 .expect("Expected function, got error.");
2058 (sym)(handle, nCaptures)
2059 }
2060 pub unsafe fn ps6000GetNoOfProcessedCaptures(
2061 &self,
2062 handle: i16,
2063 nProcessedCaptures: *mut u32,
2064 ) -> PICO_STATUS {
2065 let sym = self
2066 .ps6000GetNoOfProcessedCaptures
2067 .as_ref()
2068 .expect("Expected function, got error.");
2069 (sym)(handle, nProcessedCaptures)
2070 }
2071 pub unsafe fn ps6000Stop(&self, handle: i16) -> PICO_STATUS {
2072 let sym = self
2073 .ps6000Stop
2074 .as_ref()
2075 .expect("Expected function, got error.");
2076 (sym)(handle)
2077 }
2078 pub unsafe fn ps6000SetNoOfCaptures(&self, handle: i16, nCaptures: u32) -> PICO_STATUS {
2079 let sym = self
2080 .ps6000SetNoOfCaptures
2081 .as_ref()
2082 .expect("Expected function, got error.");
2083 (sym)(handle, nCaptures)
2084 }
2085 pub unsafe fn ps6000SetWaveformLimiter(
2086 &self,
2087 handle: i16,
2088 nWaveformsPerSecond: u32,
2089 ) -> PICO_STATUS {
2090 let sym = self
2091 .ps6000SetWaveformLimiter
2092 .as_ref()
2093 .expect("Expected function, got error.");
2094 (sym)(handle, nWaveformsPerSecond)
2095 }
2096 pub unsafe fn ps6000GetTriggerInfoBulk(
2097 &self,
2098 handle: i16,
2099 triggerInfo: *mut PS6000_TRIGGER_INFO,
2100 fromSegmentIndex: u32,
2101 toSegmentIndex: u32,
2102 ) -> PICO_STATUS {
2103 let sym = self
2104 .ps6000GetTriggerInfoBulk
2105 .as_ref()
2106 .expect("Expected function, got error.");
2107 (sym)(handle, triggerInfo, fromSegmentIndex, toSegmentIndex)
2108 }
2109 pub unsafe fn ps6000EnumerateUnits(
2110 &self,
2111 count: *mut i16,
2112 serials: *mut i8,
2113 serialLth: *mut i16,
2114 ) -> PICO_STATUS {
2115 let sym = self
2116 .ps6000EnumerateUnits
2117 .as_ref()
2118 .expect("Expected function, got error.");
2119 (sym)(count, serials, serialLth)
2120 }
2121 pub unsafe fn ps6000SetExternalClock(
2122 &self,
2123 handle: i16,
2124 frequency: PS6000_EXTERNAL_FREQUENCY,
2125 threshold: i16,
2126 ) -> PICO_STATUS {
2127 let sym = self
2128 .ps6000SetExternalClock
2129 .as_ref()
2130 .expect("Expected function, got error.");
2131 (sym)(handle, frequency, threshold)
2132 }
2133 pub unsafe fn ps6000PingUnit(&self, handle: i16) -> PICO_STATUS {
2134 let sym = self
2135 .ps6000PingUnit
2136 .as_ref()
2137 .expect("Expected function, got error.");
2138 (sym)(handle)
2139 }
2140 pub unsafe fn ps6000GetAnalogueOffset(
2141 &self,
2142 handle: i16,
2143 range: PS6000_RANGE,
2144 coupling: PS6000_COUPLING,
2145 maximumVoltage: *mut f32,
2146 minimumVoltage: *mut f32,
2147 ) -> PICO_STATUS {
2148 let sym = self
2149 .ps6000GetAnalogueOffset
2150 .as_ref()
2151 .expect("Expected function, got error.");
2152 (sym)(handle, range, coupling, maximumVoltage, minimumVoltage)
2153 }
2154 pub unsafe fn ps6000QueryTemperatures(
2155 &self,
2156 handle: i16,
2157 types: *mut PS6000_TEMPERATURES,
2158 temperatures: *mut f32,
2159 ) -> PICO_STATUS {
2160 let sym = self
2161 .ps6000QueryTemperatures
2162 .as_ref()
2163 .expect("Expected function, got error.");
2164 (sym)(handle, types, temperatures)
2165 }
2166 pub unsafe fn ps6000QueryOutputEdgeDetect(&self, handle: i16, state: *mut i16) -> PICO_STATUS {
2167 let sym = self
2168 .ps6000QueryOutputEdgeDetect
2169 .as_ref()
2170 .expect("Expected function, got error.");
2171 (sym)(handle, state)
2172 }
2173 pub unsafe fn ps6000SetOutputEdgeDetect(&self, handle: i16, state: i16) -> PICO_STATUS {
2174 let sym = self
2175 .ps6000SetOutputEdgeDetect
2176 .as_ref()
2177 .expect("Expected function, got error.");
2178 (sym)(handle, state)
2179 }
2180}