1pub const _STDINT_H: u32 = 1;
4pub const _FEATURES_H: u32 = 1;
5pub const _DEFAULT_SOURCE: u32 = 1;
6pub const __GLIBC_USE_ISOC2X: u32 = 0;
7pub const __USE_ISOC11: u32 = 1;
8pub const __USE_ISOC99: u32 = 1;
9pub const __USE_ISOC95: u32 = 1;
10pub const __USE_POSIX_IMPLICITLY: u32 = 1;
11pub const _POSIX_SOURCE: u32 = 1;
12pub const _POSIX_C_SOURCE: u32 = 200809;
13pub const __USE_POSIX: u32 = 1;
14pub const __USE_POSIX2: u32 = 1;
15pub const __USE_POSIX199309: u32 = 1;
16pub const __USE_POSIX199506: u32 = 1;
17pub const __USE_XOPEN2K: u32 = 1;
18pub const __USE_XOPEN2K8: u32 = 1;
19pub const _ATFILE_SOURCE: u32 = 1;
20pub const __WORDSIZE: u32 = 64;
21pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
22pub const __SYSCALL_WORDSIZE: u32 = 64;
23pub const __TIMESIZE: u32 = 64;
24pub const __USE_MISC: u32 = 1;
25pub const __USE_ATFILE: u32 = 1;
26pub const __USE_FORTIFY_LEVEL: u32 = 0;
27pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
28pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
29pub const _STDC_PREDEF_H: u32 = 1;
30pub const __STDC_IEC_559__: u32 = 1;
31pub const __STDC_IEC_60559_BFP__: u32 = 201404;
32pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
33pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
34pub const __STDC_ISO_10646__: u32 = 201706;
35pub const __GNU_LIBRARY__: u32 = 6;
36pub const __GLIBC__: u32 = 2;
37pub const __GLIBC_MINOR__: u32 = 35;
38pub const _SYS_CDEFS_H: u32 = 1;
39pub const __glibc_c99_flexarr_available: u32 = 1;
40pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
41pub const __HAVE_GENERIC_SELECTION: u32 = 1;
42pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
43pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
44pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
45pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
46pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
47pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
48pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
49pub const _BITS_TYPES_H: u32 = 1;
50pub const _BITS_TYPESIZES_H: u32 = 1;
51pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
52pub const __INO_T_MATCHES_INO64_T: u32 = 1;
53pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
54pub const __STATFS_MATCHES_STATFS64: u32 = 1;
55pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
56pub const __FD_SETSIZE: u32 = 1024;
57pub const _BITS_TIME64_H: u32 = 1;
58pub const _BITS_WCHAR_H: u32 = 1;
59pub const _BITS_STDINT_INTN_H: u32 = 1;
60pub const _BITS_STDINT_UINTN_H: u32 = 1;
61pub const INT8_MIN: i32 = -128;
62pub const INT16_MIN: i32 = -32768;
63pub const INT32_MIN: i32 = -2147483648;
64pub const INT8_MAX: u32 = 127;
65pub const INT16_MAX: u32 = 32767;
66pub const INT32_MAX: u32 = 2147483647;
67pub const UINT8_MAX: u32 = 255;
68pub const UINT16_MAX: u32 = 65535;
69pub const UINT32_MAX: u32 = 4294967295;
70pub const INT_LEAST8_MIN: i32 = -128;
71pub const INT_LEAST16_MIN: i32 = -32768;
72pub const INT_LEAST32_MIN: i32 = -2147483648;
73pub const INT_LEAST8_MAX: u32 = 127;
74pub const INT_LEAST16_MAX: u32 = 32767;
75pub const INT_LEAST32_MAX: u32 = 2147483647;
76pub const UINT_LEAST8_MAX: u32 = 255;
77pub const UINT_LEAST16_MAX: u32 = 65535;
78pub const UINT_LEAST32_MAX: u32 = 4294967295;
79pub const INT_FAST8_MIN: i32 = -128;
80pub const INT_FAST16_MIN: i64 = -9223372036854775808;
81pub const INT_FAST32_MIN: i64 = -9223372036854775808;
82pub const INT_FAST8_MAX: u32 = 127;
83pub const INT_FAST16_MAX: u64 = 9223372036854775807;
84pub const INT_FAST32_MAX: u64 = 9223372036854775807;
85pub const UINT_FAST8_MAX: u32 = 255;
86pub const UINT_FAST16_MAX: i32 = -1;
87pub const UINT_FAST32_MAX: i32 = -1;
88pub const INTPTR_MIN: i64 = -9223372036854775808;
89pub const INTPTR_MAX: u64 = 9223372036854775807;
90pub const UINTPTR_MAX: i32 = -1;
91pub const PTRDIFF_MIN: i64 = -9223372036854775808;
92pub const PTRDIFF_MAX: u64 = 9223372036854775807;
93pub const SIG_ATOMIC_MIN: i32 = -2147483648;
94pub const SIG_ATOMIC_MAX: u32 = 2147483647;
95pub const SIZE_MAX: i32 = -1;
96pub const WINT_MIN: u32 = 0;
97pub const WINT_MAX: u32 = 4294967295;
98pub const _STDLIB_H: u32 = 1;
99pub const WNOHANG: u32 = 1;
100pub const WUNTRACED: u32 = 2;
101pub const WSTOPPED: u32 = 2;
102pub const WEXITED: u32 = 4;
103pub const WCONTINUED: u32 = 8;
104pub const WNOWAIT: u32 = 16777216;
105pub const __WNOTHREAD: u32 = 536870912;
106pub const __WALL: u32 = 1073741824;
107pub const __WCLONE: u32 = 2147483648;
108pub const __W_CONTINUED: u32 = 65535;
109pub const __WCOREFLAG: u32 = 128;
110pub const __HAVE_FLOAT128: u32 = 0;
111pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
112pub const __HAVE_FLOAT64X: u32 = 1;
113pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
114pub const __HAVE_FLOAT16: u32 = 0;
115pub const __HAVE_FLOAT32: u32 = 1;
116pub const __HAVE_FLOAT64: u32 = 1;
117pub const __HAVE_FLOAT32X: u32 = 1;
118pub const __HAVE_FLOAT128X: u32 = 0;
119pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
120pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
121pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
122pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
123pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
124pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
125pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
126pub const __ldiv_t_defined: u32 = 1;
127pub const __lldiv_t_defined: u32 = 1;
128pub const RAND_MAX: u32 = 2147483647;
129pub const EXIT_FAILURE: u32 = 1;
130pub const EXIT_SUCCESS: u32 = 0;
131pub const _SYS_TYPES_H: u32 = 1;
132pub const __clock_t_defined: u32 = 1;
133pub const __clockid_t_defined: u32 = 1;
134pub const __time_t_defined: u32 = 1;
135pub const __timer_t_defined: u32 = 1;
136pub const __BIT_TYPES_DEFINED__: u32 = 1;
137pub const _ENDIAN_H: u32 = 1;
138pub const _BITS_ENDIAN_H: u32 = 1;
139pub const __LITTLE_ENDIAN: u32 = 1234;
140pub const __BIG_ENDIAN: u32 = 4321;
141pub const __PDP_ENDIAN: u32 = 3412;
142pub const _BITS_ENDIANNESS_H: u32 = 1;
143pub const __BYTE_ORDER: u32 = 1234;
144pub const __FLOAT_WORD_ORDER: u32 = 1234;
145pub const LITTLE_ENDIAN: u32 = 1234;
146pub const BIG_ENDIAN: u32 = 4321;
147pub const PDP_ENDIAN: u32 = 3412;
148pub const BYTE_ORDER: u32 = 1234;
149pub const _BITS_BYTESWAP_H: u32 = 1;
150pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
151pub const _SYS_SELECT_H: u32 = 1;
152pub const __sigset_t_defined: u32 = 1;
153pub const __timeval_defined: u32 = 1;
154pub const _STRUCT_TIMESPEC: u32 = 1;
155pub const FD_SETSIZE: u32 = 1024;
156pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
157pub const _THREAD_SHARED_TYPES_H: u32 = 1;
158pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
159pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
160pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
161pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
162pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
163pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
164pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
165pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
166pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
167pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
168pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
169pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
170pub const __have_pthread_attr_t: u32 = 1;
171pub const _ALLOCA_H: u32 = 1;
172pub const PUNK_BOOL: u32 = 2;
173pub const PUNK_INT8: u32 = 127;
174pub const PUNK_UINT8: u32 = 255;
175pub const PUNK_INT16: u32 = 32767;
176pub const PUNK_UINT16: u32 = 65535;
177pub const PUNK_INT32: u32 = 2147483647;
178pub const PUNK_UINT32: u32 = 4294967295;
179pub const PUNK_DBL : f64 = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 ;
180pub const PUNK_FLT: f64 = 1000000000000000000000000000000.0;
181pub const PUNK_ENUM: u32 = 2147483647;
182pub const PUNK_SIZE: i32 = -1;
183pub const PFALSE: u32 = 0;
184pub const PTRUE: u32 = 1;
185pub const PRIphid: &[u8; 2] = b"P\0";
186pub const PHIDGET_SERIALNUMBER_ANY: i32 = -1;
187pub const PHIDGET_HUBPORT_ANY: i32 = -1;
188pub const PHIDGET_CHANNEL_ANY: i32 = -1;
189pub const PHIDGET_TIMEOUT_INFINITE: u32 = 0;
190pub const PHIDGET_TIMEOUT_DEFAULT: u32 = 1000;
191pub const PHIDGET_HUBPORTSPEED_AUTO: u32 = 0;
192pub const PHIDGETSERVER_AUTHREQUIRED: u32 = 1;
193pub const IR_RAWDATA_LONGSPACE: u32 = 4294967295;
194pub const IR_MAX_CODE_BIT_COUNT: u32 = 128;
195pub const IR_MAX_CODE_STR_LENGTH: u32 = 33;
196pub type __u_char = ::std::os::raw::c_uchar;
197pub type __u_short = ::std::os::raw::c_ushort;
198pub type __u_int = ::std::os::raw::c_uint;
199pub type __u_long = ::std::os::raw::c_ulong;
200pub type __int8_t = ::std::os::raw::c_schar;
201pub type __uint8_t = ::std::os::raw::c_uchar;
202pub type __int16_t = ::std::os::raw::c_short;
203pub type __uint16_t = ::std::os::raw::c_ushort;
204pub type __int32_t = ::std::os::raw::c_int;
205pub type __uint32_t = ::std::os::raw::c_uint;
206pub type __int64_t = ::std::os::raw::c_long;
207pub type __uint64_t = ::std::os::raw::c_ulong;
208pub type __int_least8_t = __int8_t;
209pub type __uint_least8_t = __uint8_t;
210pub type __int_least16_t = __int16_t;
211pub type __uint_least16_t = __uint16_t;
212pub type __int_least32_t = __int32_t;
213pub type __uint_least32_t = __uint32_t;
214pub type __int_least64_t = __int64_t;
215pub type __uint_least64_t = __uint64_t;
216pub type __quad_t = ::std::os::raw::c_long;
217pub type __u_quad_t = ::std::os::raw::c_ulong;
218pub type __intmax_t = ::std::os::raw::c_long;
219pub type __uintmax_t = ::std::os::raw::c_ulong;
220pub type __dev_t = ::std::os::raw::c_ulong;
221pub type __uid_t = ::std::os::raw::c_uint;
222pub type __gid_t = ::std::os::raw::c_uint;
223pub type __ino_t = ::std::os::raw::c_ulong;
224pub type __ino64_t = ::std::os::raw::c_ulong;
225pub type __mode_t = ::std::os::raw::c_uint;
226pub type __nlink_t = ::std::os::raw::c_ulong;
227pub type __off_t = ::std::os::raw::c_long;
228pub type __off64_t = ::std::os::raw::c_long;
229pub type __pid_t = ::std::os::raw::c_int;
230#[repr(C)]
231#[derive(Debug, Copy, Clone)]
232pub struct __fsid_t {
233 pub __val: [::std::os::raw::c_int; 2usize],
234}
235#[test]
236fn bindgen_test_layout___fsid_t() {
237 const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
238 let ptr = UNINIT.as_ptr();
239 assert_eq!(
240 ::std::mem::size_of::<__fsid_t>(),
241 8usize,
242 "Size of __fsid_t"
243 );
244 assert_eq!(
245 ::std::mem::align_of::<__fsid_t>(),
246 4usize,
247 "Alignment of __fsid_t"
248 );
249 assert_eq!(
250 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
251 0usize,
252 "Offset of field: __fsid_t::__val"
253 );
254}
255pub type __clock_t = ::std::os::raw::c_long;
256pub type __rlim_t = ::std::os::raw::c_ulong;
257pub type __rlim64_t = ::std::os::raw::c_ulong;
258pub type __id_t = ::std::os::raw::c_uint;
259pub type __time_t = ::std::os::raw::c_long;
260pub type __useconds_t = ::std::os::raw::c_uint;
261pub type __suseconds_t = ::std::os::raw::c_long;
262pub type __suseconds64_t = ::std::os::raw::c_long;
263pub type __daddr_t = ::std::os::raw::c_int;
264pub type __key_t = ::std::os::raw::c_int;
265pub type __clockid_t = ::std::os::raw::c_int;
266pub type __timer_t = *mut ::std::os::raw::c_void;
267pub type __blksize_t = ::std::os::raw::c_long;
268pub type __blkcnt_t = ::std::os::raw::c_long;
269pub type __blkcnt64_t = ::std::os::raw::c_long;
270pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
271pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
272pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
273pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
274pub type __fsword_t = ::std::os::raw::c_long;
275pub type __ssize_t = ::std::os::raw::c_long;
276pub type __syscall_slong_t = ::std::os::raw::c_long;
277pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
278pub type __loff_t = __off64_t;
279pub type __caddr_t = *mut ::std::os::raw::c_char;
280pub type __intptr_t = ::std::os::raw::c_long;
281pub type __socklen_t = ::std::os::raw::c_uint;
282pub type __sig_atomic_t = ::std::os::raw::c_int;
283pub type int_least8_t = __int_least8_t;
284pub type int_least16_t = __int_least16_t;
285pub type int_least32_t = __int_least32_t;
286pub type int_least64_t = __int_least64_t;
287pub type uint_least8_t = __uint_least8_t;
288pub type uint_least16_t = __uint_least16_t;
289pub type uint_least32_t = __uint_least32_t;
290pub type uint_least64_t = __uint_least64_t;
291pub type int_fast8_t = ::std::os::raw::c_schar;
292pub type int_fast16_t = ::std::os::raw::c_long;
293pub type int_fast32_t = ::std::os::raw::c_long;
294pub type int_fast64_t = ::std::os::raw::c_long;
295pub type uint_fast8_t = ::std::os::raw::c_uchar;
296pub type uint_fast16_t = ::std::os::raw::c_ulong;
297pub type uint_fast32_t = ::std::os::raw::c_ulong;
298pub type uint_fast64_t = ::std::os::raw::c_ulong;
299pub type intmax_t = __intmax_t;
300pub type uintmax_t = __uintmax_t;
301pub type __gnuc_va_list = __builtin_va_list;
302pub type va_list = __builtin_va_list;
303pub type wchar_t = ::std::os::raw::c_int;
304#[repr(C)]
305#[repr(align(16))]
306#[derive(Debug, Copy, Clone)]
307pub struct max_align_t {
308 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
309 pub __bindgen_padding_0: u64,
310 pub __clang_max_align_nonce2: u128,
311}
312#[test]
313fn bindgen_test_layout_max_align_t() {
314 const UNINIT: ::std::mem::MaybeUninit<max_align_t> = ::std::mem::MaybeUninit::uninit();
315 let ptr = UNINIT.as_ptr();
316 assert_eq!(
317 ::std::mem::size_of::<max_align_t>(),
318 32usize,
319 "Size of max_align_t"
320 );
321 assert_eq!(
322 ::std::mem::align_of::<max_align_t>(),
323 16usize,
324 "Alignment of max_align_t"
325 );
326 assert_eq!(
327 unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
328 0usize,
329 "Offset of field: max_align_t::__clang_max_align_nonce1"
330 );
331 assert_eq!(
332 unsafe { ::std::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
333 16usize,
334 "Offset of field: max_align_t::__clang_max_align_nonce2"
335 );
336}
337pub type _Float32 = f32;
338pub type _Float64 = f64;
339pub type _Float32x = f64;
340pub type _Float64x = u128;
341#[repr(C)]
342#[derive(Debug, Copy, Clone)]
343pub struct div_t {
344 pub quot: ::std::os::raw::c_int,
345 pub rem: ::std::os::raw::c_int,
346}
347#[test]
348fn bindgen_test_layout_div_t() {
349 const UNINIT: ::std::mem::MaybeUninit<div_t> = ::std::mem::MaybeUninit::uninit();
350 let ptr = UNINIT.as_ptr();
351 assert_eq!(::std::mem::size_of::<div_t>(), 8usize, "Size of div_t");
352 assert_eq!(
353 ::std::mem::align_of::<div_t>(),
354 4usize,
355 "Alignment of div_t"
356 );
357 assert_eq!(
358 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
359 0usize,
360 "Offset of field: div_t::quot"
361 );
362 assert_eq!(
363 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
364 4usize,
365 "Offset of field: div_t::rem"
366 );
367}
368#[repr(C)]
369#[derive(Debug, Copy, Clone)]
370pub struct ldiv_t {
371 pub quot: ::std::os::raw::c_long,
372 pub rem: ::std::os::raw::c_long,
373}
374#[test]
375fn bindgen_test_layout_ldiv_t() {
376 const UNINIT: ::std::mem::MaybeUninit<ldiv_t> = ::std::mem::MaybeUninit::uninit();
377 let ptr = UNINIT.as_ptr();
378 assert_eq!(::std::mem::size_of::<ldiv_t>(), 16usize, "Size of ldiv_t");
379 assert_eq!(
380 ::std::mem::align_of::<ldiv_t>(),
381 8usize,
382 "Alignment of ldiv_t"
383 );
384 assert_eq!(
385 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
386 0usize,
387 "Offset of field: ldiv_t::quot"
388 );
389 assert_eq!(
390 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
391 8usize,
392 "Offset of field: ldiv_t::rem"
393 );
394}
395#[repr(C)]
396#[derive(Debug, Copy, Clone)]
397pub struct lldiv_t {
398 pub quot: ::std::os::raw::c_longlong,
399 pub rem: ::std::os::raw::c_longlong,
400}
401#[test]
402fn bindgen_test_layout_lldiv_t() {
403 const UNINIT: ::std::mem::MaybeUninit<lldiv_t> = ::std::mem::MaybeUninit::uninit();
404 let ptr = UNINIT.as_ptr();
405 assert_eq!(::std::mem::size_of::<lldiv_t>(), 16usize, "Size of lldiv_t");
406 assert_eq!(
407 ::std::mem::align_of::<lldiv_t>(),
408 8usize,
409 "Alignment of lldiv_t"
410 );
411 assert_eq!(
412 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
413 0usize,
414 "Offset of field: lldiv_t::quot"
415 );
416 assert_eq!(
417 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
418 8usize,
419 "Offset of field: lldiv_t::rem"
420 );
421}
422extern "C" {
423 pub fn __ctype_get_mb_cur_max() -> usize;
424}
425extern "C" {
426 pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
427}
428extern "C" {
429 pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
430}
431extern "C" {
432 pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
433}
434extern "C" {
435 pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
436}
437extern "C" {
438 pub fn strtod(
439 __nptr: *const ::std::os::raw::c_char,
440 __endptr: *mut *mut ::std::os::raw::c_char,
441 ) -> f64;
442}
443extern "C" {
444 pub fn strtof(
445 __nptr: *const ::std::os::raw::c_char,
446 __endptr: *mut *mut ::std::os::raw::c_char,
447 ) -> f32;
448}
449extern "C" {
450 pub fn strtold(
451 __nptr: *const ::std::os::raw::c_char,
452 __endptr: *mut *mut ::std::os::raw::c_char,
453 ) -> u128;
454}
455extern "C" {
456 pub fn strtol(
457 __nptr: *const ::std::os::raw::c_char,
458 __endptr: *mut *mut ::std::os::raw::c_char,
459 __base: ::std::os::raw::c_int,
460 ) -> ::std::os::raw::c_long;
461}
462extern "C" {
463 pub fn strtoul(
464 __nptr: *const ::std::os::raw::c_char,
465 __endptr: *mut *mut ::std::os::raw::c_char,
466 __base: ::std::os::raw::c_int,
467 ) -> ::std::os::raw::c_ulong;
468}
469extern "C" {
470 pub fn strtoq(
471 __nptr: *const ::std::os::raw::c_char,
472 __endptr: *mut *mut ::std::os::raw::c_char,
473 __base: ::std::os::raw::c_int,
474 ) -> ::std::os::raw::c_longlong;
475}
476extern "C" {
477 pub fn strtouq(
478 __nptr: *const ::std::os::raw::c_char,
479 __endptr: *mut *mut ::std::os::raw::c_char,
480 __base: ::std::os::raw::c_int,
481 ) -> ::std::os::raw::c_ulonglong;
482}
483extern "C" {
484 pub fn strtoll(
485 __nptr: *const ::std::os::raw::c_char,
486 __endptr: *mut *mut ::std::os::raw::c_char,
487 __base: ::std::os::raw::c_int,
488 ) -> ::std::os::raw::c_longlong;
489}
490extern "C" {
491 pub fn strtoull(
492 __nptr: *const ::std::os::raw::c_char,
493 __endptr: *mut *mut ::std::os::raw::c_char,
494 __base: ::std::os::raw::c_int,
495 ) -> ::std::os::raw::c_ulonglong;
496}
497extern "C" {
498 pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
499}
500extern "C" {
501 pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
502}
503pub type u_char = __u_char;
504pub type u_short = __u_short;
505pub type u_int = __u_int;
506pub type u_long = __u_long;
507pub type quad_t = __quad_t;
508pub type u_quad_t = __u_quad_t;
509pub type fsid_t = __fsid_t;
510pub type loff_t = __loff_t;
511pub type ino_t = __ino_t;
512pub type dev_t = __dev_t;
513pub type gid_t = __gid_t;
514pub type mode_t = __mode_t;
515pub type nlink_t = __nlink_t;
516pub type uid_t = __uid_t;
517pub type off_t = __off_t;
518pub type pid_t = __pid_t;
519pub type id_t = __id_t;
520pub type daddr_t = __daddr_t;
521pub type caddr_t = __caddr_t;
522pub type key_t = __key_t;
523pub type clock_t = __clock_t;
524pub type clockid_t = __clockid_t;
525pub type time_t = __time_t;
526pub type timer_t = __timer_t;
527pub type ulong = ::std::os::raw::c_ulong;
528pub type ushort = ::std::os::raw::c_ushort;
529pub type uint = ::std::os::raw::c_uint;
530pub type u_int8_t = __uint8_t;
531pub type u_int16_t = __uint16_t;
532pub type u_int32_t = __uint32_t;
533pub type u_int64_t = __uint64_t;
534pub type register_t = ::std::os::raw::c_long;
535#[repr(C)]
536#[derive(Debug, Copy, Clone)]
537pub struct __sigset_t {
538 pub __val: [::std::os::raw::c_ulong; 16usize],
539}
540#[test]
541fn bindgen_test_layout___sigset_t() {
542 const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
543 let ptr = UNINIT.as_ptr();
544 assert_eq!(
545 ::std::mem::size_of::<__sigset_t>(),
546 128usize,
547 "Size of __sigset_t"
548 );
549 assert_eq!(
550 ::std::mem::align_of::<__sigset_t>(),
551 8usize,
552 "Alignment of __sigset_t"
553 );
554 assert_eq!(
555 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
556 0usize,
557 "Offset of field: __sigset_t::__val"
558 );
559}
560pub type sigset_t = __sigset_t;
561#[repr(C)]
562#[derive(Debug, Copy, Clone)]
563pub struct timeval {
564 pub tv_sec: __time_t,
565 pub tv_usec: __suseconds_t,
566}
567#[test]
568fn bindgen_test_layout_timeval() {
569 const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
570 let ptr = UNINIT.as_ptr();
571 assert_eq!(::std::mem::size_of::<timeval>(), 16usize, "Size of timeval");
572 assert_eq!(
573 ::std::mem::align_of::<timeval>(),
574 8usize,
575 "Alignment of timeval"
576 );
577 assert_eq!(
578 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
579 0usize,
580 "Offset of field: timeval::tv_sec"
581 );
582 assert_eq!(
583 unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
584 8usize,
585 "Offset of field: timeval::tv_usec"
586 );
587}
588#[repr(C)]
589#[derive(Debug, Copy, Clone)]
590pub struct timespec {
591 pub tv_sec: __time_t,
592 pub tv_nsec: __syscall_slong_t,
593}
594#[test]
595fn bindgen_test_layout_timespec() {
596 const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
597 let ptr = UNINIT.as_ptr();
598 assert_eq!(
599 ::std::mem::size_of::<timespec>(),
600 16usize,
601 "Size of timespec"
602 );
603 assert_eq!(
604 ::std::mem::align_of::<timespec>(),
605 8usize,
606 "Alignment of timespec"
607 );
608 assert_eq!(
609 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
610 0usize,
611 "Offset of field: timespec::tv_sec"
612 );
613 assert_eq!(
614 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
615 8usize,
616 "Offset of field: timespec::tv_nsec"
617 );
618}
619pub type suseconds_t = __suseconds_t;
620pub type __fd_mask = ::std::os::raw::c_long;
621#[repr(C)]
622#[derive(Debug, Copy, Clone)]
623pub struct fd_set {
624 pub __fds_bits: [__fd_mask; 16usize],
625}
626#[test]
627fn bindgen_test_layout_fd_set() {
628 const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
629 let ptr = UNINIT.as_ptr();
630 assert_eq!(::std::mem::size_of::<fd_set>(), 128usize, "Size of fd_set");
631 assert_eq!(
632 ::std::mem::align_of::<fd_set>(),
633 8usize,
634 "Alignment of fd_set"
635 );
636 assert_eq!(
637 unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
638 0usize,
639 "Offset of field: fd_set::__fds_bits"
640 );
641}
642pub type fd_mask = __fd_mask;
643extern "C" {
644 pub fn select(
645 __nfds: ::std::os::raw::c_int,
646 __readfds: *mut fd_set,
647 __writefds: *mut fd_set,
648 __exceptfds: *mut fd_set,
649 __timeout: *mut timeval,
650 ) -> ::std::os::raw::c_int;
651}
652extern "C" {
653 pub fn pselect(
654 __nfds: ::std::os::raw::c_int,
655 __readfds: *mut fd_set,
656 __writefds: *mut fd_set,
657 __exceptfds: *mut fd_set,
658 __timeout: *const timespec,
659 __sigmask: *const __sigset_t,
660 ) -> ::std::os::raw::c_int;
661}
662pub type blksize_t = __blksize_t;
663pub type blkcnt_t = __blkcnt_t;
664pub type fsblkcnt_t = __fsblkcnt_t;
665pub type fsfilcnt_t = __fsfilcnt_t;
666#[repr(C)]
667#[derive(Copy, Clone)]
668pub union __atomic_wide_counter {
669 pub __value64: ::std::os::raw::c_ulonglong,
670 pub __value32: __atomic_wide_counter__bindgen_ty_1,
671}
672#[repr(C)]
673#[derive(Debug, Copy, Clone)]
674pub struct __atomic_wide_counter__bindgen_ty_1 {
675 pub __low: ::std::os::raw::c_uint,
676 pub __high: ::std::os::raw::c_uint,
677}
678#[test]
679fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
680 const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
681 ::std::mem::MaybeUninit::uninit();
682 let ptr = UNINIT.as_ptr();
683 assert_eq!(
684 ::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
685 8usize,
686 "Size of __atomic_wide_counter__bindgen_ty_1"
687 );
688 assert_eq!(
689 ::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
690 4usize,
691 "Alignment of __atomic_wide_counter__bindgen_ty_1"
692 );
693 assert_eq!(
694 unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
695 0usize,
696 "Offset of field: __atomic_wide_counter__bindgen_ty_1::__low"
697 );
698 assert_eq!(
699 unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
700 4usize,
701 "Offset of field: __atomic_wide_counter__bindgen_ty_1::__high"
702 );
703}
704#[test]
705fn bindgen_test_layout___atomic_wide_counter() {
706 const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
707 ::std::mem::MaybeUninit::uninit();
708 let ptr = UNINIT.as_ptr();
709 assert_eq!(
710 ::std::mem::size_of::<__atomic_wide_counter>(),
711 8usize,
712 "Size of __atomic_wide_counter"
713 );
714 assert_eq!(
715 ::std::mem::align_of::<__atomic_wide_counter>(),
716 8usize,
717 "Alignment of __atomic_wide_counter"
718 );
719 assert_eq!(
720 unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
721 0usize,
722 "Offset of field: __atomic_wide_counter::__value64"
723 );
724 assert_eq!(
725 unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
726 0usize,
727 "Offset of field: __atomic_wide_counter::__value32"
728 );
729}
730#[repr(C)]
731#[derive(Debug, Copy, Clone)]
732pub struct __pthread_internal_list {
733 pub __prev: *mut __pthread_internal_list,
734 pub __next: *mut __pthread_internal_list,
735}
736#[test]
737fn bindgen_test_layout___pthread_internal_list() {
738 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
739 ::std::mem::MaybeUninit::uninit();
740 let ptr = UNINIT.as_ptr();
741 assert_eq!(
742 ::std::mem::size_of::<__pthread_internal_list>(),
743 16usize,
744 "Size of __pthread_internal_list"
745 );
746 assert_eq!(
747 ::std::mem::align_of::<__pthread_internal_list>(),
748 8usize,
749 "Alignment of __pthread_internal_list"
750 );
751 assert_eq!(
752 unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
753 0usize,
754 "Offset of field: __pthread_internal_list::__prev"
755 );
756 assert_eq!(
757 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
758 8usize,
759 "Offset of field: __pthread_internal_list::__next"
760 );
761}
762pub type __pthread_list_t = __pthread_internal_list;
763#[repr(C)]
764#[derive(Debug, Copy, Clone)]
765pub struct __pthread_internal_slist {
766 pub __next: *mut __pthread_internal_slist,
767}
768#[test]
769fn bindgen_test_layout___pthread_internal_slist() {
770 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
771 ::std::mem::MaybeUninit::uninit();
772 let ptr = UNINIT.as_ptr();
773 assert_eq!(
774 ::std::mem::size_of::<__pthread_internal_slist>(),
775 8usize,
776 "Size of __pthread_internal_slist"
777 );
778 assert_eq!(
779 ::std::mem::align_of::<__pthread_internal_slist>(),
780 8usize,
781 "Alignment of __pthread_internal_slist"
782 );
783 assert_eq!(
784 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
785 0usize,
786 "Offset of field: __pthread_internal_slist::__next"
787 );
788}
789pub type __pthread_slist_t = __pthread_internal_slist;
790#[repr(C)]
791#[derive(Debug, Copy, Clone)]
792pub struct __pthread_mutex_s {
793 pub __lock: ::std::os::raw::c_int,
794 pub __count: ::std::os::raw::c_uint,
795 pub __owner: ::std::os::raw::c_int,
796 pub __nusers: ::std::os::raw::c_uint,
797 pub __kind: ::std::os::raw::c_int,
798 pub __spins: ::std::os::raw::c_short,
799 pub __elision: ::std::os::raw::c_short,
800 pub __list: __pthread_list_t,
801}
802#[test]
803fn bindgen_test_layout___pthread_mutex_s() {
804 const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
805 let ptr = UNINIT.as_ptr();
806 assert_eq!(
807 ::std::mem::size_of::<__pthread_mutex_s>(),
808 40usize,
809 "Size of __pthread_mutex_s"
810 );
811 assert_eq!(
812 ::std::mem::align_of::<__pthread_mutex_s>(),
813 8usize,
814 "Alignment of __pthread_mutex_s"
815 );
816 assert_eq!(
817 unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
818 0usize,
819 "Offset of field: __pthread_mutex_s::__lock"
820 );
821 assert_eq!(
822 unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
823 4usize,
824 "Offset of field: __pthread_mutex_s::__count"
825 );
826 assert_eq!(
827 unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
828 8usize,
829 "Offset of field: __pthread_mutex_s::__owner"
830 );
831 assert_eq!(
832 unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
833 12usize,
834 "Offset of field: __pthread_mutex_s::__nusers"
835 );
836 assert_eq!(
837 unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
838 16usize,
839 "Offset of field: __pthread_mutex_s::__kind"
840 );
841 assert_eq!(
842 unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
843 20usize,
844 "Offset of field: __pthread_mutex_s::__spins"
845 );
846 assert_eq!(
847 unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
848 22usize,
849 "Offset of field: __pthread_mutex_s::__elision"
850 );
851 assert_eq!(
852 unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
853 24usize,
854 "Offset of field: __pthread_mutex_s::__list"
855 );
856}
857#[repr(C)]
858#[derive(Debug, Copy, Clone)]
859pub struct __pthread_rwlock_arch_t {
860 pub __readers: ::std::os::raw::c_uint,
861 pub __writers: ::std::os::raw::c_uint,
862 pub __wrphase_futex: ::std::os::raw::c_uint,
863 pub __writers_futex: ::std::os::raw::c_uint,
864 pub __pad3: ::std::os::raw::c_uint,
865 pub __pad4: ::std::os::raw::c_uint,
866 pub __cur_writer: ::std::os::raw::c_int,
867 pub __shared: ::std::os::raw::c_int,
868 pub __rwelision: ::std::os::raw::c_schar,
869 pub __pad1: [::std::os::raw::c_uchar; 7usize],
870 pub __pad2: ::std::os::raw::c_ulong,
871 pub __flags: ::std::os::raw::c_uint,
872}
873#[test]
874fn bindgen_test_layout___pthread_rwlock_arch_t() {
875 const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
876 ::std::mem::MaybeUninit::uninit();
877 let ptr = UNINIT.as_ptr();
878 assert_eq!(
879 ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
880 56usize,
881 "Size of __pthread_rwlock_arch_t"
882 );
883 assert_eq!(
884 ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
885 8usize,
886 "Alignment of __pthread_rwlock_arch_t"
887 );
888 assert_eq!(
889 unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
890 0usize,
891 "Offset of field: __pthread_rwlock_arch_t::__readers"
892 );
893 assert_eq!(
894 unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
895 4usize,
896 "Offset of field: __pthread_rwlock_arch_t::__writers"
897 );
898 assert_eq!(
899 unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
900 8usize,
901 "Offset of field: __pthread_rwlock_arch_t::__wrphase_futex"
902 );
903 assert_eq!(
904 unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
905 12usize,
906 "Offset of field: __pthread_rwlock_arch_t::__writers_futex"
907 );
908 assert_eq!(
909 unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
910 16usize,
911 "Offset of field: __pthread_rwlock_arch_t::__pad3"
912 );
913 assert_eq!(
914 unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
915 20usize,
916 "Offset of field: __pthread_rwlock_arch_t::__pad4"
917 );
918 assert_eq!(
919 unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
920 24usize,
921 "Offset of field: __pthread_rwlock_arch_t::__cur_writer"
922 );
923 assert_eq!(
924 unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
925 28usize,
926 "Offset of field: __pthread_rwlock_arch_t::__shared"
927 );
928 assert_eq!(
929 unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
930 32usize,
931 "Offset of field: __pthread_rwlock_arch_t::__rwelision"
932 );
933 assert_eq!(
934 unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
935 33usize,
936 "Offset of field: __pthread_rwlock_arch_t::__pad1"
937 );
938 assert_eq!(
939 unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
940 40usize,
941 "Offset of field: __pthread_rwlock_arch_t::__pad2"
942 );
943 assert_eq!(
944 unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
945 48usize,
946 "Offset of field: __pthread_rwlock_arch_t::__flags"
947 );
948}
949#[repr(C)]
950#[derive(Copy, Clone)]
951pub struct __pthread_cond_s {
952 pub __wseq: __atomic_wide_counter,
953 pub __g1_start: __atomic_wide_counter,
954 pub __g_refs: [::std::os::raw::c_uint; 2usize],
955 pub __g_size: [::std::os::raw::c_uint; 2usize],
956 pub __g1_orig_size: ::std::os::raw::c_uint,
957 pub __wrefs: ::std::os::raw::c_uint,
958 pub __g_signals: [::std::os::raw::c_uint; 2usize],
959}
960#[test]
961fn bindgen_test_layout___pthread_cond_s() {
962 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
963 let ptr = UNINIT.as_ptr();
964 assert_eq!(
965 ::std::mem::size_of::<__pthread_cond_s>(),
966 48usize,
967 "Size of __pthread_cond_s"
968 );
969 assert_eq!(
970 ::std::mem::align_of::<__pthread_cond_s>(),
971 8usize,
972 "Alignment of __pthread_cond_s"
973 );
974 assert_eq!(
975 unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
976 0usize,
977 "Offset of field: __pthread_cond_s::__wseq"
978 );
979 assert_eq!(
980 unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
981 8usize,
982 "Offset of field: __pthread_cond_s::__g1_start"
983 );
984 assert_eq!(
985 unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
986 16usize,
987 "Offset of field: __pthread_cond_s::__g_refs"
988 );
989 assert_eq!(
990 unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
991 24usize,
992 "Offset of field: __pthread_cond_s::__g_size"
993 );
994 assert_eq!(
995 unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
996 32usize,
997 "Offset of field: __pthread_cond_s::__g1_orig_size"
998 );
999 assert_eq!(
1000 unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
1001 36usize,
1002 "Offset of field: __pthread_cond_s::__wrefs"
1003 );
1004 assert_eq!(
1005 unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
1006 40usize,
1007 "Offset of field: __pthread_cond_s::__g_signals"
1008 );
1009}
1010pub type __tss_t = ::std::os::raw::c_uint;
1011pub type __thrd_t = ::std::os::raw::c_ulong;
1012#[repr(C)]
1013#[derive(Debug, Copy, Clone)]
1014pub struct __once_flag {
1015 pub __data: ::std::os::raw::c_int,
1016}
1017#[test]
1018fn bindgen_test_layout___once_flag() {
1019 const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
1020 let ptr = UNINIT.as_ptr();
1021 assert_eq!(
1022 ::std::mem::size_of::<__once_flag>(),
1023 4usize,
1024 "Size of __once_flag"
1025 );
1026 assert_eq!(
1027 ::std::mem::align_of::<__once_flag>(),
1028 4usize,
1029 "Alignment of __once_flag"
1030 );
1031 assert_eq!(
1032 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1033 0usize,
1034 "Offset of field: __once_flag::__data"
1035 );
1036}
1037pub type pthread_t = ::std::os::raw::c_ulong;
1038#[repr(C)]
1039#[derive(Copy, Clone)]
1040pub union pthread_mutexattr_t {
1041 pub __size: [::std::os::raw::c_char; 4usize],
1042 pub __align: ::std::os::raw::c_int,
1043}
1044#[test]
1045fn bindgen_test_layout_pthread_mutexattr_t() {
1046 const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
1047 let ptr = UNINIT.as_ptr();
1048 assert_eq!(
1049 ::std::mem::size_of::<pthread_mutexattr_t>(),
1050 4usize,
1051 "Size of pthread_mutexattr_t"
1052 );
1053 assert_eq!(
1054 ::std::mem::align_of::<pthread_mutexattr_t>(),
1055 4usize,
1056 "Alignment of pthread_mutexattr_t"
1057 );
1058 assert_eq!(
1059 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1060 0usize,
1061 "Offset of field: pthread_mutexattr_t::__size"
1062 );
1063 assert_eq!(
1064 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1065 0usize,
1066 "Offset of field: pthread_mutexattr_t::__align"
1067 );
1068}
1069#[repr(C)]
1070#[derive(Copy, Clone)]
1071pub union pthread_condattr_t {
1072 pub __size: [::std::os::raw::c_char; 4usize],
1073 pub __align: ::std::os::raw::c_int,
1074}
1075#[test]
1076fn bindgen_test_layout_pthread_condattr_t() {
1077 const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
1078 let ptr = UNINIT.as_ptr();
1079 assert_eq!(
1080 ::std::mem::size_of::<pthread_condattr_t>(),
1081 4usize,
1082 "Size of pthread_condattr_t"
1083 );
1084 assert_eq!(
1085 ::std::mem::align_of::<pthread_condattr_t>(),
1086 4usize,
1087 "Alignment of pthread_condattr_t"
1088 );
1089 assert_eq!(
1090 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1091 0usize,
1092 "Offset of field: pthread_condattr_t::__size"
1093 );
1094 assert_eq!(
1095 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1096 0usize,
1097 "Offset of field: pthread_condattr_t::__align"
1098 );
1099}
1100pub type pthread_key_t = ::std::os::raw::c_uint;
1101pub type pthread_once_t = ::std::os::raw::c_int;
1102#[repr(C)]
1103#[derive(Copy, Clone)]
1104pub union pthread_attr_t {
1105 pub __size: [::std::os::raw::c_char; 56usize],
1106 pub __align: ::std::os::raw::c_long,
1107}
1108#[test]
1109fn bindgen_test_layout_pthread_attr_t() {
1110 const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
1111 let ptr = UNINIT.as_ptr();
1112 assert_eq!(
1113 ::std::mem::size_of::<pthread_attr_t>(),
1114 56usize,
1115 "Size of pthread_attr_t"
1116 );
1117 assert_eq!(
1118 ::std::mem::align_of::<pthread_attr_t>(),
1119 8usize,
1120 "Alignment of pthread_attr_t"
1121 );
1122 assert_eq!(
1123 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1124 0usize,
1125 "Offset of field: pthread_attr_t::__size"
1126 );
1127 assert_eq!(
1128 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1129 0usize,
1130 "Offset of field: pthread_attr_t::__align"
1131 );
1132}
1133#[repr(C)]
1134#[derive(Copy, Clone)]
1135pub union pthread_mutex_t {
1136 pub __data: __pthread_mutex_s,
1137 pub __size: [::std::os::raw::c_char; 40usize],
1138 pub __align: ::std::os::raw::c_long,
1139}
1140#[test]
1141fn bindgen_test_layout_pthread_mutex_t() {
1142 const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
1143 let ptr = UNINIT.as_ptr();
1144 assert_eq!(
1145 ::std::mem::size_of::<pthread_mutex_t>(),
1146 40usize,
1147 "Size of pthread_mutex_t"
1148 );
1149 assert_eq!(
1150 ::std::mem::align_of::<pthread_mutex_t>(),
1151 8usize,
1152 "Alignment of pthread_mutex_t"
1153 );
1154 assert_eq!(
1155 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1156 0usize,
1157 "Offset of field: pthread_mutex_t::__data"
1158 );
1159 assert_eq!(
1160 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1161 0usize,
1162 "Offset of field: pthread_mutex_t::__size"
1163 );
1164 assert_eq!(
1165 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1166 0usize,
1167 "Offset of field: pthread_mutex_t::__align"
1168 );
1169}
1170#[repr(C)]
1171#[derive(Copy, Clone)]
1172pub union pthread_cond_t {
1173 pub __data: __pthread_cond_s,
1174 pub __size: [::std::os::raw::c_char; 48usize],
1175 pub __align: ::std::os::raw::c_longlong,
1176}
1177#[test]
1178fn bindgen_test_layout_pthread_cond_t() {
1179 const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
1180 let ptr = UNINIT.as_ptr();
1181 assert_eq!(
1182 ::std::mem::size_of::<pthread_cond_t>(),
1183 48usize,
1184 "Size of pthread_cond_t"
1185 );
1186 assert_eq!(
1187 ::std::mem::align_of::<pthread_cond_t>(),
1188 8usize,
1189 "Alignment of pthread_cond_t"
1190 );
1191 assert_eq!(
1192 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1193 0usize,
1194 "Offset of field: pthread_cond_t::__data"
1195 );
1196 assert_eq!(
1197 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1198 0usize,
1199 "Offset of field: pthread_cond_t::__size"
1200 );
1201 assert_eq!(
1202 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1203 0usize,
1204 "Offset of field: pthread_cond_t::__align"
1205 );
1206}
1207#[repr(C)]
1208#[derive(Copy, Clone)]
1209pub union pthread_rwlock_t {
1210 pub __data: __pthread_rwlock_arch_t,
1211 pub __size: [::std::os::raw::c_char; 56usize],
1212 pub __align: ::std::os::raw::c_long,
1213}
1214#[test]
1215fn bindgen_test_layout_pthread_rwlock_t() {
1216 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
1217 let ptr = UNINIT.as_ptr();
1218 assert_eq!(
1219 ::std::mem::size_of::<pthread_rwlock_t>(),
1220 56usize,
1221 "Size of pthread_rwlock_t"
1222 );
1223 assert_eq!(
1224 ::std::mem::align_of::<pthread_rwlock_t>(),
1225 8usize,
1226 "Alignment of pthread_rwlock_t"
1227 );
1228 assert_eq!(
1229 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1230 0usize,
1231 "Offset of field: pthread_rwlock_t::__data"
1232 );
1233 assert_eq!(
1234 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1235 0usize,
1236 "Offset of field: pthread_rwlock_t::__size"
1237 );
1238 assert_eq!(
1239 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1240 0usize,
1241 "Offset of field: pthread_rwlock_t::__align"
1242 );
1243}
1244#[repr(C)]
1245#[derive(Copy, Clone)]
1246pub union pthread_rwlockattr_t {
1247 pub __size: [::std::os::raw::c_char; 8usize],
1248 pub __align: ::std::os::raw::c_long,
1249}
1250#[test]
1251fn bindgen_test_layout_pthread_rwlockattr_t() {
1252 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
1253 let ptr = UNINIT.as_ptr();
1254 assert_eq!(
1255 ::std::mem::size_of::<pthread_rwlockattr_t>(),
1256 8usize,
1257 "Size of pthread_rwlockattr_t"
1258 );
1259 assert_eq!(
1260 ::std::mem::align_of::<pthread_rwlockattr_t>(),
1261 8usize,
1262 "Alignment of pthread_rwlockattr_t"
1263 );
1264 assert_eq!(
1265 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1266 0usize,
1267 "Offset of field: pthread_rwlockattr_t::__size"
1268 );
1269 assert_eq!(
1270 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1271 0usize,
1272 "Offset of field: pthread_rwlockattr_t::__align"
1273 );
1274}
1275pub type pthread_spinlock_t = ::std::os::raw::c_int;
1276#[repr(C)]
1277#[derive(Copy, Clone)]
1278pub union pthread_barrier_t {
1279 pub __size: [::std::os::raw::c_char; 32usize],
1280 pub __align: ::std::os::raw::c_long,
1281}
1282#[test]
1283fn bindgen_test_layout_pthread_barrier_t() {
1284 const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
1285 let ptr = UNINIT.as_ptr();
1286 assert_eq!(
1287 ::std::mem::size_of::<pthread_barrier_t>(),
1288 32usize,
1289 "Size of pthread_barrier_t"
1290 );
1291 assert_eq!(
1292 ::std::mem::align_of::<pthread_barrier_t>(),
1293 8usize,
1294 "Alignment of pthread_barrier_t"
1295 );
1296 assert_eq!(
1297 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1298 0usize,
1299 "Offset of field: pthread_barrier_t::__size"
1300 );
1301 assert_eq!(
1302 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1303 0usize,
1304 "Offset of field: pthread_barrier_t::__align"
1305 );
1306}
1307#[repr(C)]
1308#[derive(Copy, Clone)]
1309pub union pthread_barrierattr_t {
1310 pub __size: [::std::os::raw::c_char; 4usize],
1311 pub __align: ::std::os::raw::c_int,
1312}
1313#[test]
1314fn bindgen_test_layout_pthread_barrierattr_t() {
1315 const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
1316 ::std::mem::MaybeUninit::uninit();
1317 let ptr = UNINIT.as_ptr();
1318 assert_eq!(
1319 ::std::mem::size_of::<pthread_barrierattr_t>(),
1320 4usize,
1321 "Size of pthread_barrierattr_t"
1322 );
1323 assert_eq!(
1324 ::std::mem::align_of::<pthread_barrierattr_t>(),
1325 4usize,
1326 "Alignment of pthread_barrierattr_t"
1327 );
1328 assert_eq!(
1329 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1330 0usize,
1331 "Offset of field: pthread_barrierattr_t::__size"
1332 );
1333 assert_eq!(
1334 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1335 0usize,
1336 "Offset of field: pthread_barrierattr_t::__align"
1337 );
1338}
1339extern "C" {
1340 pub fn random() -> ::std::os::raw::c_long;
1341}
1342extern "C" {
1343 pub fn srandom(__seed: ::std::os::raw::c_uint);
1344}
1345extern "C" {
1346 pub fn initstate(
1347 __seed: ::std::os::raw::c_uint,
1348 __statebuf: *mut ::std::os::raw::c_char,
1349 __statelen: usize,
1350 ) -> *mut ::std::os::raw::c_char;
1351}
1352extern "C" {
1353 pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1354}
1355#[repr(C)]
1356#[derive(Debug, Copy, Clone)]
1357pub struct random_data {
1358 pub fptr: *mut i32,
1359 pub rptr: *mut i32,
1360 pub state: *mut i32,
1361 pub rand_type: ::std::os::raw::c_int,
1362 pub rand_deg: ::std::os::raw::c_int,
1363 pub rand_sep: ::std::os::raw::c_int,
1364 pub end_ptr: *mut i32,
1365}
1366#[test]
1367fn bindgen_test_layout_random_data() {
1368 const UNINIT: ::std::mem::MaybeUninit<random_data> = ::std::mem::MaybeUninit::uninit();
1369 let ptr = UNINIT.as_ptr();
1370 assert_eq!(
1371 ::std::mem::size_of::<random_data>(),
1372 48usize,
1373 "Size of random_data"
1374 );
1375 assert_eq!(
1376 ::std::mem::align_of::<random_data>(),
1377 8usize,
1378 "Alignment of random_data"
1379 );
1380 assert_eq!(
1381 unsafe { ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
1382 0usize,
1383 "Offset of field: random_data::fptr"
1384 );
1385 assert_eq!(
1386 unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
1387 8usize,
1388 "Offset of field: random_data::rptr"
1389 );
1390 assert_eq!(
1391 unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
1392 16usize,
1393 "Offset of field: random_data::state"
1394 );
1395 assert_eq!(
1396 unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
1397 24usize,
1398 "Offset of field: random_data::rand_type"
1399 );
1400 assert_eq!(
1401 unsafe { ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
1402 28usize,
1403 "Offset of field: random_data::rand_deg"
1404 );
1405 assert_eq!(
1406 unsafe { ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
1407 32usize,
1408 "Offset of field: random_data::rand_sep"
1409 );
1410 assert_eq!(
1411 unsafe { ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize },
1412 40usize,
1413 "Offset of field: random_data::end_ptr"
1414 );
1415}
1416extern "C" {
1417 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
1418}
1419extern "C" {
1420 pub fn srandom_r(
1421 __seed: ::std::os::raw::c_uint,
1422 __buf: *mut random_data,
1423 ) -> ::std::os::raw::c_int;
1424}
1425extern "C" {
1426 pub fn initstate_r(
1427 __seed: ::std::os::raw::c_uint,
1428 __statebuf: *mut ::std::os::raw::c_char,
1429 __statelen: usize,
1430 __buf: *mut random_data,
1431 ) -> ::std::os::raw::c_int;
1432}
1433extern "C" {
1434 pub fn setstate_r(
1435 __statebuf: *mut ::std::os::raw::c_char,
1436 __buf: *mut random_data,
1437 ) -> ::std::os::raw::c_int;
1438}
1439extern "C" {
1440 pub fn rand() -> ::std::os::raw::c_int;
1441}
1442extern "C" {
1443 pub fn srand(__seed: ::std::os::raw::c_uint);
1444}
1445extern "C" {
1446 pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
1447}
1448extern "C" {
1449 pub fn drand48() -> f64;
1450}
1451extern "C" {
1452 pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
1453}
1454extern "C" {
1455 pub fn lrand48() -> ::std::os::raw::c_long;
1456}
1457extern "C" {
1458 pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1459}
1460extern "C" {
1461 pub fn mrand48() -> ::std::os::raw::c_long;
1462}
1463extern "C" {
1464 pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
1465}
1466extern "C" {
1467 pub fn srand48(__seedval: ::std::os::raw::c_long);
1468}
1469extern "C" {
1470 pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
1471}
1472extern "C" {
1473 pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
1474}
1475#[repr(C)]
1476#[derive(Debug, Copy, Clone)]
1477pub struct drand48_data {
1478 pub __x: [::std::os::raw::c_ushort; 3usize],
1479 pub __old_x: [::std::os::raw::c_ushort; 3usize],
1480 pub __c: ::std::os::raw::c_ushort,
1481 pub __init: ::std::os::raw::c_ushort,
1482 pub __a: ::std::os::raw::c_ulonglong,
1483}
1484#[test]
1485fn bindgen_test_layout_drand48_data() {
1486 const UNINIT: ::std::mem::MaybeUninit<drand48_data> = ::std::mem::MaybeUninit::uninit();
1487 let ptr = UNINIT.as_ptr();
1488 assert_eq!(
1489 ::std::mem::size_of::<drand48_data>(),
1490 24usize,
1491 "Size of drand48_data"
1492 );
1493 assert_eq!(
1494 ::std::mem::align_of::<drand48_data>(),
1495 8usize,
1496 "Alignment of drand48_data"
1497 );
1498 assert_eq!(
1499 unsafe { ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
1500 0usize,
1501 "Offset of field: drand48_data::__x"
1502 );
1503 assert_eq!(
1504 unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
1505 6usize,
1506 "Offset of field: drand48_data::__old_x"
1507 );
1508 assert_eq!(
1509 unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
1510 12usize,
1511 "Offset of field: drand48_data::__c"
1512 );
1513 assert_eq!(
1514 unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
1515 14usize,
1516 "Offset of field: drand48_data::__init"
1517 );
1518 assert_eq!(
1519 unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
1520 16usize,
1521 "Offset of field: drand48_data::__a"
1522 );
1523}
1524extern "C" {
1525 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
1526}
1527extern "C" {
1528 pub fn erand48_r(
1529 __xsubi: *mut ::std::os::raw::c_ushort,
1530 __buffer: *mut drand48_data,
1531 __result: *mut f64,
1532 ) -> ::std::os::raw::c_int;
1533}
1534extern "C" {
1535 pub fn lrand48_r(
1536 __buffer: *mut drand48_data,
1537 __result: *mut ::std::os::raw::c_long,
1538 ) -> ::std::os::raw::c_int;
1539}
1540extern "C" {
1541 pub fn nrand48_r(
1542 __xsubi: *mut ::std::os::raw::c_ushort,
1543 __buffer: *mut drand48_data,
1544 __result: *mut ::std::os::raw::c_long,
1545 ) -> ::std::os::raw::c_int;
1546}
1547extern "C" {
1548 pub fn mrand48_r(
1549 __buffer: *mut drand48_data,
1550 __result: *mut ::std::os::raw::c_long,
1551 ) -> ::std::os::raw::c_int;
1552}
1553extern "C" {
1554 pub fn jrand48_r(
1555 __xsubi: *mut ::std::os::raw::c_ushort,
1556 __buffer: *mut drand48_data,
1557 __result: *mut ::std::os::raw::c_long,
1558 ) -> ::std::os::raw::c_int;
1559}
1560extern "C" {
1561 pub fn srand48_r(
1562 __seedval: ::std::os::raw::c_long,
1563 __buffer: *mut drand48_data,
1564 ) -> ::std::os::raw::c_int;
1565}
1566extern "C" {
1567 pub fn seed48_r(
1568 __seed16v: *mut ::std::os::raw::c_ushort,
1569 __buffer: *mut drand48_data,
1570 ) -> ::std::os::raw::c_int;
1571}
1572extern "C" {
1573 pub fn lcong48_r(
1574 __param: *mut ::std::os::raw::c_ushort,
1575 __buffer: *mut drand48_data,
1576 ) -> ::std::os::raw::c_int;
1577}
1578extern "C" {
1579 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1580}
1581extern "C" {
1582 pub fn calloc(
1583 __nmemb: ::std::os::raw::c_ulong,
1584 __size: ::std::os::raw::c_ulong,
1585 ) -> *mut ::std::os::raw::c_void;
1586}
1587extern "C" {
1588 pub fn realloc(
1589 __ptr: *mut ::std::os::raw::c_void,
1590 __size: ::std::os::raw::c_ulong,
1591 ) -> *mut ::std::os::raw::c_void;
1592}
1593extern "C" {
1594 pub fn free(__ptr: *mut ::std::os::raw::c_void);
1595}
1596extern "C" {
1597 pub fn reallocarray(
1598 __ptr: *mut ::std::os::raw::c_void,
1599 __nmemb: usize,
1600 __size: usize,
1601 ) -> *mut ::std::os::raw::c_void;
1602}
1603extern "C" {
1604 pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
1605}
1606extern "C" {
1607 pub fn valloc(__size: usize) -> *mut ::std::os::raw::c_void;
1608}
1609extern "C" {
1610 pub fn posix_memalign(
1611 __memptr: *mut *mut ::std::os::raw::c_void,
1612 __alignment: usize,
1613 __size: usize,
1614 ) -> ::std::os::raw::c_int;
1615}
1616extern "C" {
1617 pub fn aligned_alloc(
1618 __alignment: ::std::os::raw::c_ulong,
1619 __size: ::std::os::raw::c_ulong,
1620 ) -> *mut ::std::os::raw::c_void;
1621}
1622extern "C" {
1623 pub fn abort() -> !;
1624}
1625extern "C" {
1626 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
1627}
1628extern "C" {
1629 pub fn at_quick_exit(
1630 __func: ::std::option::Option<unsafe extern "C" fn()>,
1631 ) -> ::std::os::raw::c_int;
1632}
1633extern "C" {
1634 pub fn on_exit(
1635 __func: ::std::option::Option<
1636 unsafe extern "C" fn(
1637 __status: ::std::os::raw::c_int,
1638 __arg: *mut ::std::os::raw::c_void,
1639 ),
1640 >,
1641 __arg: *mut ::std::os::raw::c_void,
1642 ) -> ::std::os::raw::c_int;
1643}
1644extern "C" {
1645 pub fn exit(__status: ::std::os::raw::c_int) -> !;
1646}
1647extern "C" {
1648 pub fn quick_exit(__status: ::std::os::raw::c_int) -> !;
1649}
1650extern "C" {
1651 pub fn _Exit(__status: ::std::os::raw::c_int) -> !;
1652}
1653extern "C" {
1654 pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1655}
1656extern "C" {
1657 pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1658}
1659extern "C" {
1660 pub fn setenv(
1661 __name: *const ::std::os::raw::c_char,
1662 __value: *const ::std::os::raw::c_char,
1663 __replace: ::std::os::raw::c_int,
1664 ) -> ::std::os::raw::c_int;
1665}
1666extern "C" {
1667 pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1668}
1669extern "C" {
1670 pub fn clearenv() -> ::std::os::raw::c_int;
1671}
1672extern "C" {
1673 pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1674}
1675extern "C" {
1676 pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1677}
1678extern "C" {
1679 pub fn mkstemps(
1680 __template: *mut ::std::os::raw::c_char,
1681 __suffixlen: ::std::os::raw::c_int,
1682 ) -> ::std::os::raw::c_int;
1683}
1684extern "C" {
1685 pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1686}
1687extern "C" {
1688 pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1689}
1690extern "C" {
1691 pub fn realpath(
1692 __name: *const ::std::os::raw::c_char,
1693 __resolved: *mut ::std::os::raw::c_char,
1694 ) -> *mut ::std::os::raw::c_char;
1695}
1696pub type __compar_fn_t = ::std::option::Option<
1697 unsafe extern "C" fn(
1698 arg1: *const ::std::os::raw::c_void,
1699 arg2: *const ::std::os::raw::c_void,
1700 ) -> ::std::os::raw::c_int,
1701>;
1702extern "C" {
1703 pub fn bsearch(
1704 __key: *const ::std::os::raw::c_void,
1705 __base: *const ::std::os::raw::c_void,
1706 __nmemb: usize,
1707 __size: usize,
1708 __compar: __compar_fn_t,
1709 ) -> *mut ::std::os::raw::c_void;
1710}
1711extern "C" {
1712 pub fn qsort(
1713 __base: *mut ::std::os::raw::c_void,
1714 __nmemb: usize,
1715 __size: usize,
1716 __compar: __compar_fn_t,
1717 );
1718}
1719extern "C" {
1720 pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1721}
1722extern "C" {
1723 pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
1724}
1725extern "C" {
1726 pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
1727}
1728extern "C" {
1729 pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
1730}
1731extern "C" {
1732 pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
1733}
1734extern "C" {
1735 pub fn lldiv(
1736 __numer: ::std::os::raw::c_longlong,
1737 __denom: ::std::os::raw::c_longlong,
1738 ) -> lldiv_t;
1739}
1740extern "C" {
1741 pub fn ecvt(
1742 __value: f64,
1743 __ndigit: ::std::os::raw::c_int,
1744 __decpt: *mut ::std::os::raw::c_int,
1745 __sign: *mut ::std::os::raw::c_int,
1746 ) -> *mut ::std::os::raw::c_char;
1747}
1748extern "C" {
1749 pub fn fcvt(
1750 __value: f64,
1751 __ndigit: ::std::os::raw::c_int,
1752 __decpt: *mut ::std::os::raw::c_int,
1753 __sign: *mut ::std::os::raw::c_int,
1754 ) -> *mut ::std::os::raw::c_char;
1755}
1756extern "C" {
1757 pub fn gcvt(
1758 __value: f64,
1759 __ndigit: ::std::os::raw::c_int,
1760 __buf: *mut ::std::os::raw::c_char,
1761 ) -> *mut ::std::os::raw::c_char;
1762}
1763extern "C" {
1764 pub fn qecvt(
1765 __value: u128,
1766 __ndigit: ::std::os::raw::c_int,
1767 __decpt: *mut ::std::os::raw::c_int,
1768 __sign: *mut ::std::os::raw::c_int,
1769 ) -> *mut ::std::os::raw::c_char;
1770}
1771extern "C" {
1772 pub fn qfcvt(
1773 __value: u128,
1774 __ndigit: ::std::os::raw::c_int,
1775 __decpt: *mut ::std::os::raw::c_int,
1776 __sign: *mut ::std::os::raw::c_int,
1777 ) -> *mut ::std::os::raw::c_char;
1778}
1779extern "C" {
1780 pub fn qgcvt(
1781 __value: u128,
1782 __ndigit: ::std::os::raw::c_int,
1783 __buf: *mut ::std::os::raw::c_char,
1784 ) -> *mut ::std::os::raw::c_char;
1785}
1786extern "C" {
1787 pub fn ecvt_r(
1788 __value: f64,
1789 __ndigit: ::std::os::raw::c_int,
1790 __decpt: *mut ::std::os::raw::c_int,
1791 __sign: *mut ::std::os::raw::c_int,
1792 __buf: *mut ::std::os::raw::c_char,
1793 __len: usize,
1794 ) -> ::std::os::raw::c_int;
1795}
1796extern "C" {
1797 pub fn fcvt_r(
1798 __value: f64,
1799 __ndigit: ::std::os::raw::c_int,
1800 __decpt: *mut ::std::os::raw::c_int,
1801 __sign: *mut ::std::os::raw::c_int,
1802 __buf: *mut ::std::os::raw::c_char,
1803 __len: usize,
1804 ) -> ::std::os::raw::c_int;
1805}
1806extern "C" {
1807 pub fn qecvt_r(
1808 __value: u128,
1809 __ndigit: ::std::os::raw::c_int,
1810 __decpt: *mut ::std::os::raw::c_int,
1811 __sign: *mut ::std::os::raw::c_int,
1812 __buf: *mut ::std::os::raw::c_char,
1813 __len: usize,
1814 ) -> ::std::os::raw::c_int;
1815}
1816extern "C" {
1817 pub fn qfcvt_r(
1818 __value: u128,
1819 __ndigit: ::std::os::raw::c_int,
1820 __decpt: *mut ::std::os::raw::c_int,
1821 __sign: *mut ::std::os::raw::c_int,
1822 __buf: *mut ::std::os::raw::c_char,
1823 __len: usize,
1824 ) -> ::std::os::raw::c_int;
1825}
1826extern "C" {
1827 pub fn mblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
1828}
1829extern "C" {
1830 pub fn mbtowc(
1831 __pwc: *mut wchar_t,
1832 __s: *const ::std::os::raw::c_char,
1833 __n: usize,
1834 ) -> ::std::os::raw::c_int;
1835}
1836extern "C" {
1837 pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
1838}
1839extern "C" {
1840 pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char, __n: usize) -> usize;
1841}
1842extern "C" {
1843 pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
1844}
1845extern "C" {
1846 pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1847}
1848extern "C" {
1849 pub fn getsubopt(
1850 __optionp: *mut *mut ::std::os::raw::c_char,
1851 __tokens: *const *mut ::std::os::raw::c_char,
1852 __valuep: *mut *mut ::std::os::raw::c_char,
1853 ) -> ::std::os::raw::c_int;
1854}
1855extern "C" {
1856 pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
1857 -> ::std::os::raw::c_int;
1858}
1859pub const Phidget_EncoderIOMode_ENCODER_IO_MODE_PUSH_PULL: Phidget_EncoderIOMode = 1;
1860pub const Phidget_EncoderIOMode_ENCODER_IO_MODE_LINE_DRIVER_2K2: Phidget_EncoderIOMode = 2;
1861pub const Phidget_EncoderIOMode_ENCODER_IO_MODE_LINE_DRIVER_10K: Phidget_EncoderIOMode = 3;
1862pub const Phidget_EncoderIOMode_ENCODER_IO_MODE_OPEN_COLLECTOR_2K2: Phidget_EncoderIOMode = 4;
1863pub const Phidget_EncoderIOMode_ENCODER_IO_MODE_OPEN_COLLECTOR_10K: Phidget_EncoderIOMode = 5;
1864pub type Phidget_EncoderIOMode = ::std::os::raw::c_uint;
1865pub const PhidgetReturnCode_EPHIDGET_OK: PhidgetReturnCode = 0;
1866pub const PhidgetReturnCode_EPHIDGET_PERM: PhidgetReturnCode = 1;
1867pub const PhidgetReturnCode_EPHIDGET_NOENT: PhidgetReturnCode = 2;
1868pub const PhidgetReturnCode_EPHIDGET_TIMEOUT: PhidgetReturnCode = 3;
1869pub const PhidgetReturnCode_EPHIDGET_KEEPALIVE: PhidgetReturnCode = 58;
1870pub const PhidgetReturnCode_EPHIDGET_INTERRUPTED: PhidgetReturnCode = 4;
1871pub const PhidgetReturnCode_EPHIDGET_IO: PhidgetReturnCode = 5;
1872pub const PhidgetReturnCode_EPHIDGET_NOMEMORY: PhidgetReturnCode = 6;
1873pub const PhidgetReturnCode_EPHIDGET_ACCESS: PhidgetReturnCode = 7;
1874pub const PhidgetReturnCode_EPHIDGET_FAULT: PhidgetReturnCode = 8;
1875pub const PhidgetReturnCode_EPHIDGET_BUSY: PhidgetReturnCode = 9;
1876pub const PhidgetReturnCode_EPHIDGET_EXIST: PhidgetReturnCode = 10;
1877pub const PhidgetReturnCode_EPHIDGET_NOTDIR: PhidgetReturnCode = 11;
1878pub const PhidgetReturnCode_EPHIDGET_ISDIR: PhidgetReturnCode = 12;
1879pub const PhidgetReturnCode_EPHIDGET_INVALID: PhidgetReturnCode = 13;
1880pub const PhidgetReturnCode_EPHIDGET_NFILE: PhidgetReturnCode = 14;
1881pub const PhidgetReturnCode_EPHIDGET_MFILE: PhidgetReturnCode = 15;
1882pub const PhidgetReturnCode_EPHIDGET_NOSPC: PhidgetReturnCode = 16;
1883pub const PhidgetReturnCode_EPHIDGET_FBIG: PhidgetReturnCode = 17;
1884pub const PhidgetReturnCode_EPHIDGET_ROFS: PhidgetReturnCode = 18;
1885pub const PhidgetReturnCode_EPHIDGET_RO: PhidgetReturnCode = 19;
1886pub const PhidgetReturnCode_EPHIDGET_UNSUPPORTED: PhidgetReturnCode = 20;
1887pub const PhidgetReturnCode_EPHIDGET_INVALIDARG: PhidgetReturnCode = 21;
1888pub const PhidgetReturnCode_EPHIDGET_AGAIN: PhidgetReturnCode = 22;
1889pub const PhidgetReturnCode_EPHIDGET_NOTEMPTY: PhidgetReturnCode = 26;
1890pub const PhidgetReturnCode_EPHIDGET_UNEXPECTED: PhidgetReturnCode = 28;
1891pub const PhidgetReturnCode_EPHIDGET_DUPLICATE: PhidgetReturnCode = 27;
1892pub const PhidgetReturnCode_EPHIDGET_BADPASSWORD: PhidgetReturnCode = 37;
1893pub const PhidgetReturnCode_EPHIDGET_NETUNAVAIL: PhidgetReturnCode = 45;
1894pub const PhidgetReturnCode_EPHIDGET_CONNREF: PhidgetReturnCode = 35;
1895pub const PhidgetReturnCode_EPHIDGET_CONNRESET: PhidgetReturnCode = 46;
1896pub const PhidgetReturnCode_EPHIDGET_HOSTUNREACH: PhidgetReturnCode = 48;
1897pub const PhidgetReturnCode_EPHIDGET_NODEV: PhidgetReturnCode = 40;
1898pub const PhidgetReturnCode_EPHIDGET_WRONGDEVICE: PhidgetReturnCode = 50;
1899pub const PhidgetReturnCode_EPHIDGET_PIPE: PhidgetReturnCode = 41;
1900pub const PhidgetReturnCode_EPHIDGET_RESOLV: PhidgetReturnCode = 44;
1901pub const PhidgetReturnCode_EPHIDGET_UNKNOWNVAL: PhidgetReturnCode = 51;
1902pub const PhidgetReturnCode_EPHIDGET_NOTATTACHED: PhidgetReturnCode = 52;
1903pub const PhidgetReturnCode_EPHIDGET_INVALIDPACKET: PhidgetReturnCode = 53;
1904pub const PhidgetReturnCode_EPHIDGET_2BIG: PhidgetReturnCode = 54;
1905pub const PhidgetReturnCode_EPHIDGET_BADVERSION: PhidgetReturnCode = 55;
1906pub const PhidgetReturnCode_EPHIDGET_CLOSED: PhidgetReturnCode = 56;
1907pub const PhidgetReturnCode_EPHIDGET_NOTCONFIGURED: PhidgetReturnCode = 57;
1908pub const PhidgetReturnCode_EPHIDGET_EOF: PhidgetReturnCode = 31;
1909pub const PhidgetReturnCode_EPHIDGET_FAILSAFE: PhidgetReturnCode = 59;
1910pub const PhidgetReturnCode_EPHIDGET_UNKNOWNVALHIGH: PhidgetReturnCode = 60;
1911pub const PhidgetReturnCode_EPHIDGET_UNKNOWNVALLOW: PhidgetReturnCode = 61;
1912pub const PhidgetReturnCode_EPHIDGET_BADPOWER: PhidgetReturnCode = 62;
1913pub const PhidgetReturnCode_EPHIDGET_POWERCYCLE: PhidgetReturnCode = 63;
1914pub const PhidgetReturnCode_EPHIDGET_HALLSENSOR: PhidgetReturnCode = 64;
1915pub const PhidgetReturnCode_EPHIDGET_BADCURRENT: PhidgetReturnCode = 65;
1916pub const PhidgetReturnCode_EPHIDGET_BADCONNECTION: PhidgetReturnCode = 66;
1917pub const PhidgetReturnCode_EPHIDGET_NACK: PhidgetReturnCode = 67;
1918pub type PhidgetReturnCode = ::std::os::raw::c_uint;
1919pub const Phidget_ErrorEventCode_EEPHIDGET_BADVERSION: Phidget_ErrorEventCode = 1;
1920pub const Phidget_ErrorEventCode_EEPHIDGET_BUSY: Phidget_ErrorEventCode = 2;
1921pub const Phidget_ErrorEventCode_EEPHIDGET_NETWORK: Phidget_ErrorEventCode = 3;
1922pub const Phidget_ErrorEventCode_EEPHIDGET_DISPATCH: Phidget_ErrorEventCode = 4;
1923pub const Phidget_ErrorEventCode_EEPHIDGET_FAILURE: Phidget_ErrorEventCode = 5;
1924pub const Phidget_ErrorEventCode_EEPHIDGET_OK: Phidget_ErrorEventCode = 4096;
1925pub const Phidget_ErrorEventCode_EEPHIDGET_OVERRUN: Phidget_ErrorEventCode = 4098;
1926pub const Phidget_ErrorEventCode_EEPHIDGET_PACKETLOST: Phidget_ErrorEventCode = 4099;
1927pub const Phidget_ErrorEventCode_EEPHIDGET_WRAP: Phidget_ErrorEventCode = 4100;
1928pub const Phidget_ErrorEventCode_EEPHIDGET_OVERTEMP: Phidget_ErrorEventCode = 4101;
1929pub const Phidget_ErrorEventCode_EEPHIDGET_OVERCURRENT: Phidget_ErrorEventCode = 4102;
1930pub const Phidget_ErrorEventCode_EEPHIDGET_OUTOFRANGE: Phidget_ErrorEventCode = 4103;
1931pub const Phidget_ErrorEventCode_EEPHIDGET_BADPOWER: Phidget_ErrorEventCode = 4104;
1932pub const Phidget_ErrorEventCode_EEPHIDGET_SATURATION: Phidget_ErrorEventCode = 4105;
1933pub const Phidget_ErrorEventCode_EEPHIDGET_OVERVOLTAGE: Phidget_ErrorEventCode = 4107;
1934pub const Phidget_ErrorEventCode_EEPHIDGET_FAILSAFE: Phidget_ErrorEventCode = 4108;
1935pub const Phidget_ErrorEventCode_EEPHIDGET_VOLTAGEERROR: Phidget_ErrorEventCode = 4109;
1936pub const Phidget_ErrorEventCode_EEPHIDGET_ENERGYDUMP: Phidget_ErrorEventCode = 4110;
1937pub const Phidget_ErrorEventCode_EEPHIDGET_MOTORSTALL: Phidget_ErrorEventCode = 4111;
1938pub const Phidget_ErrorEventCode_EEPHIDGET_INVALIDSTATE: Phidget_ErrorEventCode = 4112;
1939pub const Phidget_ErrorEventCode_EEPHIDGET_BADCONNECTION: Phidget_ErrorEventCode = 4113;
1940pub const Phidget_ErrorEventCode_EEPHIDGET_OUTOFRANGEHIGH: Phidget_ErrorEventCode = 4114;
1941pub const Phidget_ErrorEventCode_EEPHIDGET_OUTOFRANGELOW: Phidget_ErrorEventCode = 4115;
1942pub const Phidget_ErrorEventCode_EEPHIDGET_FAULT: Phidget_ErrorEventCode = 4116;
1943pub const Phidget_ErrorEventCode_EEPHIDGET_ESTOP: Phidget_ErrorEventCode = 4117;
1944pub type Phidget_ErrorEventCode = ::std::os::raw::c_uint;
1945pub const Phidget_DeviceID_PHIDID_NOTHING: Phidget_DeviceID = 0;
1946pub const Phidget_DeviceID_PHIDID_UNKNOWN: Phidget_DeviceID = 125;
1947pub const Phidget_DeviceID_PHIDID_DIGITALINPUT_PORT: Phidget_DeviceID = 95;
1948pub const Phidget_DeviceID_PHIDID_DIGITALOUTPUT_PORT: Phidget_DeviceID = 96;
1949pub const Phidget_DeviceID_PHIDID_VOLTAGEINPUT_PORT: Phidget_DeviceID = 97;
1950pub const Phidget_DeviceID_PHIDID_VOLTAGERATIOINPUT_PORT: Phidget_DeviceID = 98;
1951pub const Phidget_DeviceID_PHIDID_DICTIONARY: Phidget_DeviceID = 111;
1952pub const Phidget_DeviceID_PHIDID_1000: Phidget_DeviceID = 2;
1953pub const Phidget_DeviceID_PHIDID_1001: Phidget_DeviceID = 3;
1954pub const Phidget_DeviceID_PHIDID_1002: Phidget_DeviceID = 4;
1955pub const Phidget_DeviceID_PHIDID_1008: Phidget_DeviceID = 5;
1956pub const Phidget_DeviceID_PHIDID_1010_1013_1018_1019: Phidget_DeviceID = 6;
1957pub const Phidget_DeviceID_PHIDID_1011: Phidget_DeviceID = 7;
1958pub const Phidget_DeviceID_PHIDID_1012: Phidget_DeviceID = 8;
1959pub const Phidget_DeviceID_PHIDID_1014: Phidget_DeviceID = 9;
1960pub const Phidget_DeviceID_PHIDID_1015: Phidget_DeviceID = 10;
1961pub const Phidget_DeviceID_PHIDID_1016: Phidget_DeviceID = 11;
1962pub const Phidget_DeviceID_PHIDID_1017: Phidget_DeviceID = 12;
1963pub const Phidget_DeviceID_PHIDID_1023: Phidget_DeviceID = 13;
1964pub const Phidget_DeviceID_PHIDID_1024: Phidget_DeviceID = 14;
1965pub const Phidget_DeviceID_PHIDID_1030: Phidget_DeviceID = 15;
1966pub const Phidget_DeviceID_PHIDID_1031: Phidget_DeviceID = 16;
1967pub const Phidget_DeviceID_PHIDID_1032: Phidget_DeviceID = 17;
1968pub const Phidget_DeviceID_PHIDID_1040: Phidget_DeviceID = 18;
1969pub const Phidget_DeviceID_PHIDID_1041: Phidget_DeviceID = 19;
1970pub const Phidget_DeviceID_PHIDID_1042: Phidget_DeviceID = 20;
1971pub const Phidget_DeviceID_PHIDID_1043: Phidget_DeviceID = 21;
1972pub const Phidget_DeviceID_PHIDID_1044: Phidget_DeviceID = 22;
1973pub const Phidget_DeviceID_PHIDID_1045: Phidget_DeviceID = 23;
1974pub const Phidget_DeviceID_PHIDID_1046: Phidget_DeviceID = 24;
1975pub const Phidget_DeviceID_PHIDID_1047: Phidget_DeviceID = 25;
1976pub const Phidget_DeviceID_PHIDID_1048: Phidget_DeviceID = 26;
1977pub const Phidget_DeviceID_PHIDID_1049: Phidget_DeviceID = 27;
1978pub const Phidget_DeviceID_PHIDID_1051: Phidget_DeviceID = 28;
1979pub const Phidget_DeviceID_PHIDID_1052: Phidget_DeviceID = 29;
1980pub const Phidget_DeviceID_PHIDID_1053: Phidget_DeviceID = 30;
1981pub const Phidget_DeviceID_PHIDID_1054: Phidget_DeviceID = 31;
1982pub const Phidget_DeviceID_PHIDID_1055: Phidget_DeviceID = 32;
1983pub const Phidget_DeviceID_PHIDID_1056: Phidget_DeviceID = 33;
1984pub const Phidget_DeviceID_PHIDID_1057: Phidget_DeviceID = 34;
1985pub const Phidget_DeviceID_PHIDID_1058: Phidget_DeviceID = 35;
1986pub const Phidget_DeviceID_PHIDID_1059: Phidget_DeviceID = 36;
1987pub const Phidget_DeviceID_PHIDID_1060: Phidget_DeviceID = 37;
1988pub const Phidget_DeviceID_PHIDID_1061: Phidget_DeviceID = 38;
1989pub const Phidget_DeviceID_PHIDID_1062: Phidget_DeviceID = 39;
1990pub const Phidget_DeviceID_PHIDID_1063: Phidget_DeviceID = 40;
1991pub const Phidget_DeviceID_PHIDID_1064: Phidget_DeviceID = 41;
1992pub const Phidget_DeviceID_PHIDID_1065: Phidget_DeviceID = 42;
1993pub const Phidget_DeviceID_PHIDID_1066: Phidget_DeviceID = 43;
1994pub const Phidget_DeviceID_PHIDID_1067: Phidget_DeviceID = 44;
1995pub const Phidget_DeviceID_PHIDID_1202_1203: Phidget_DeviceID = 45;
1996pub const Phidget_DeviceID_PHIDID_1204: Phidget_DeviceID = 46;
1997pub const Phidget_DeviceID_PHIDID_1215__1218: Phidget_DeviceID = 47;
1998pub const Phidget_DeviceID_PHIDID_1219__1222: Phidget_DeviceID = 48;
1999pub const Phidget_DeviceID_PHIDID_ADP1000: Phidget_DeviceID = 49;
2000pub const Phidget_DeviceID_PHIDID_DAQ1000: Phidget_DeviceID = 51;
2001pub const Phidget_DeviceID_PHIDID_DAQ1200: Phidget_DeviceID = 52;
2002pub const Phidget_DeviceID_PHIDID_DAQ1300: Phidget_DeviceID = 53;
2003pub const Phidget_DeviceID_PHIDID_DAQ1301: Phidget_DeviceID = 54;
2004pub const Phidget_DeviceID_PHIDID_DAQ1400: Phidget_DeviceID = 55;
2005pub const Phidget_DeviceID_PHIDID_DAQ1500: Phidget_DeviceID = 56;
2006pub const Phidget_DeviceID_PHIDID_DCC1000: Phidget_DeviceID = 57;
2007pub const Phidget_DeviceID_PHIDID_DCC1001: Phidget_DeviceID = 110;
2008pub const Phidget_DeviceID_PHIDID_DCC1002: Phidget_DeviceID = 117;
2009pub const Phidget_DeviceID_PHIDID_DCC1003: Phidget_DeviceID = 120;
2010pub const Phidget_DeviceID_PHIDID_DCC1020: Phidget_DeviceID = 128;
2011pub const Phidget_DeviceID_PHIDID_DCC1030: Phidget_DeviceID = 152;
2012pub const Phidget_DeviceID_PHIDID_DCC1100: Phidget_DeviceID = 108;
2013pub const Phidget_DeviceID_PHIDID_DCC1120: Phidget_DeviceID = 150;
2014pub const Phidget_DeviceID_PHIDID_DCC1130: Phidget_DeviceID = 154;
2015pub const Phidget_DeviceID_PHIDID_DST1000: Phidget_DeviceID = 58;
2016pub const Phidget_DeviceID_PHIDID_DST1001: Phidget_DeviceID = 121;
2017pub const Phidget_DeviceID_PHIDID_DST1002: Phidget_DeviceID = 126;
2018pub const Phidget_DeviceID_PHIDID_DST1200: Phidget_DeviceID = 59;
2019pub const Phidget_DeviceID_PHIDID_ENC1000: Phidget_DeviceID = 60;
2020pub const Phidget_DeviceID_PHIDID_ENC1001: Phidget_DeviceID = 155;
2021pub const Phidget_DeviceID_PHIDID_FIRMWARE_UPGRADE_SPI: Phidget_DeviceID = 104;
2022pub const Phidget_DeviceID_PHIDID_FIRMWARE_UPGRADE_STM32F0: Phidget_DeviceID = 102;
2023pub const Phidget_DeviceID_PHIDID_FIRMWARE_UPGRADE_STM32F3: Phidget_DeviceID = 145;
2024pub const Phidget_DeviceID_PHIDID_FIRMWARE_UPGRADE_STM32G0: Phidget_DeviceID = 143;
2025pub const Phidget_DeviceID_PHIDID_FIRMWARE_UPGRADE_STM8S: Phidget_DeviceID = 103;
2026pub const Phidget_DeviceID_PHIDID_FIRMWARE_UPGRADE_USB: Phidget_DeviceID = 101;
2027pub const Phidget_DeviceID_PHIDID_HIN1000: Phidget_DeviceID = 61;
2028pub const Phidget_DeviceID_PHIDID_HIN1001: Phidget_DeviceID = 62;
2029pub const Phidget_DeviceID_PHIDID_HIN1100: Phidget_DeviceID = 63;
2030pub const Phidget_DeviceID_PHIDID_HIN1101: Phidget_DeviceID = 109;
2031pub const Phidget_DeviceID_PHIDID_HUB0000: Phidget_DeviceID = 64;
2032pub const Phidget_DeviceID_PHIDID_HUB0001: Phidget_DeviceID = 142;
2033pub const Phidget_DeviceID_PHIDID_HUB0002: Phidget_DeviceID = 147;
2034pub const Phidget_DeviceID_PHIDID_HUB0004: Phidget_DeviceID = 67;
2035pub const Phidget_DeviceID_PHIDID_HUB0007: Phidget_DeviceID = 148;
2036pub const Phidget_DeviceID_PHIDID_HUB5000: Phidget_DeviceID = 123;
2037pub const Phidget_DeviceID_PHIDID_HUM1000: Phidget_DeviceID = 69;
2038pub const Phidget_DeviceID_PHIDID_HUM1001: Phidget_DeviceID = 127;
2039pub const Phidget_DeviceID_PHIDID_HUM1100: Phidget_DeviceID = 136;
2040pub const Phidget_DeviceID_PHIDID_INTERFACEKIT_4_8_8: Phidget_DeviceID = 1;
2041pub const Phidget_DeviceID_PHIDID_LCD1100: Phidget_DeviceID = 70;
2042pub const Phidget_DeviceID_PHIDID_LED1000: Phidget_DeviceID = 71;
2043pub const Phidget_DeviceID_PHIDID_LUX1000: Phidget_DeviceID = 72;
2044pub const Phidget_DeviceID_PHIDID_MOT0100: Phidget_DeviceID = 146;
2045pub const Phidget_DeviceID_PHIDID_MOT0109: Phidget_DeviceID = 140;
2046pub const Phidget_DeviceID_PHIDID_MOT0110: Phidget_DeviceID = 141;
2047pub const Phidget_DeviceID_PHIDID_MOT1100: Phidget_DeviceID = 73;
2048pub const Phidget_DeviceID_PHIDID_MOT1101: Phidget_DeviceID = 74;
2049pub const Phidget_DeviceID_PHIDID_MOT1102: Phidget_DeviceID = 137;
2050pub const Phidget_DeviceID_PHIDID_OUT1000: Phidget_DeviceID = 75;
2051pub const Phidget_DeviceID_PHIDID_OUT1001: Phidget_DeviceID = 76;
2052pub const Phidget_DeviceID_PHIDID_OUT1002: Phidget_DeviceID = 77;
2053pub const Phidget_DeviceID_PHIDID_OUT1100: Phidget_DeviceID = 78;
2054pub const Phidget_DeviceID_PHIDID_PRE1000: Phidget_DeviceID = 79;
2055pub const Phidget_DeviceID_PHIDID_RCC0004: Phidget_DeviceID = 124;
2056pub const Phidget_DeviceID_PHIDID_RCC1000: Phidget_DeviceID = 80;
2057pub const Phidget_DeviceID_PHIDID_REL1000: Phidget_DeviceID = 81;
2058pub const Phidget_DeviceID_PHIDID_REL1100: Phidget_DeviceID = 82;
2059pub const Phidget_DeviceID_PHIDID_REL1101: Phidget_DeviceID = 83;
2060pub const Phidget_DeviceID_PHIDID_SAF1000: Phidget_DeviceID = 84;
2061pub const Phidget_DeviceID_PHIDID_SND1000: Phidget_DeviceID = 85;
2062pub const Phidget_DeviceID_PHIDID_STC1000: Phidget_DeviceID = 86;
2063pub const Phidget_DeviceID_PHIDID_STC1001: Phidget_DeviceID = 115;
2064pub const Phidget_DeviceID_PHIDID_STC1002: Phidget_DeviceID = 118;
2065pub const Phidget_DeviceID_PHIDID_STC1003: Phidget_DeviceID = 119;
2066pub const Phidget_DeviceID_PHIDID_STC1005: Phidget_DeviceID = 149;
2067pub const Phidget_DeviceID_PHIDID_TMP1000: Phidget_DeviceID = 87;
2068pub const Phidget_DeviceID_PHIDID_TMP1100: Phidget_DeviceID = 88;
2069pub const Phidget_DeviceID_PHIDID_TMP1101: Phidget_DeviceID = 89;
2070pub const Phidget_DeviceID_PHIDID_TMP1200: Phidget_DeviceID = 90;
2071pub const Phidget_DeviceID_PHIDID_VCP1000: Phidget_DeviceID = 92;
2072pub const Phidget_DeviceID_PHIDID_VCP1001: Phidget_DeviceID = 93;
2073pub const Phidget_DeviceID_PHIDID_VCP1002: Phidget_DeviceID = 94;
2074pub const Phidget_DeviceID_PHIDID_VCP1100: Phidget_DeviceID = 105;
2075pub type Phidget_DeviceID = ::std::os::raw::c_uint;
2076pub const Phidget_LogLevel_PHIDGET_LOG_CRITICAL: Phidget_LogLevel = 1;
2077pub const Phidget_LogLevel_PHIDGET_LOG_ERROR: Phidget_LogLevel = 2;
2078pub const Phidget_LogLevel_PHIDGET_LOG_WARNING: Phidget_LogLevel = 3;
2079pub const Phidget_LogLevel_PHIDGET_LOG_INFO: Phidget_LogLevel = 4;
2080pub const Phidget_LogLevel_PHIDGET_LOG_DEBUG: Phidget_LogLevel = 5;
2081pub const Phidget_LogLevel_PHIDGET_LOG_VERBOSE: Phidget_LogLevel = 6;
2082pub type Phidget_LogLevel = ::std::os::raw::c_uint;
2083pub const Phidget_DeviceClass_PHIDCLASS_NOTHING: Phidget_DeviceClass = 0;
2084pub const Phidget_DeviceClass_PHIDCLASS_ACCELEROMETER: Phidget_DeviceClass = 1;
2085pub const Phidget_DeviceClass_PHIDCLASS_ADVANCEDSERVO: Phidget_DeviceClass = 2;
2086pub const Phidget_DeviceClass_PHIDCLASS_ANALOG: Phidget_DeviceClass = 3;
2087pub const Phidget_DeviceClass_PHIDCLASS_BRIDGE: Phidget_DeviceClass = 4;
2088pub const Phidget_DeviceClass_PHIDCLASS_DATAADAPTER: Phidget_DeviceClass = 25;
2089pub const Phidget_DeviceClass_PHIDCLASS_DICTIONARY: Phidget_DeviceClass = 24;
2090pub const Phidget_DeviceClass_PHIDCLASS_ENCODER: Phidget_DeviceClass = 5;
2091pub const Phidget_DeviceClass_PHIDCLASS_FIRMWAREUPGRADE: Phidget_DeviceClass = 23;
2092pub const Phidget_DeviceClass_PHIDCLASS_FREQUENCYCOUNTER: Phidget_DeviceClass = 6;
2093pub const Phidget_DeviceClass_PHIDCLASS_GENERIC: Phidget_DeviceClass = 22;
2094pub const Phidget_DeviceClass_PHIDCLASS_GPS: Phidget_DeviceClass = 7;
2095pub const Phidget_DeviceClass_PHIDCLASS_HUB: Phidget_DeviceClass = 8;
2096pub const Phidget_DeviceClass_PHIDCLASS_INTERFACEKIT: Phidget_DeviceClass = 9;
2097pub const Phidget_DeviceClass_PHIDCLASS_IR: Phidget_DeviceClass = 10;
2098pub const Phidget_DeviceClass_PHIDCLASS_LED: Phidget_DeviceClass = 11;
2099pub const Phidget_DeviceClass_PHIDCLASS_LEDARRAY: Phidget_DeviceClass = 26;
2100pub const Phidget_DeviceClass_PHIDCLASS_MESHDONGLE: Phidget_DeviceClass = 12;
2101pub const Phidget_DeviceClass_PHIDCLASS_MOTORCONTROL: Phidget_DeviceClass = 13;
2102pub const Phidget_DeviceClass_PHIDCLASS_PHSENSOR: Phidget_DeviceClass = 14;
2103pub const Phidget_DeviceClass_PHIDCLASS_RFID: Phidget_DeviceClass = 15;
2104pub const Phidget_DeviceClass_PHIDCLASS_SERVO: Phidget_DeviceClass = 16;
2105pub const Phidget_DeviceClass_PHIDCLASS_SPATIAL: Phidget_DeviceClass = 17;
2106pub const Phidget_DeviceClass_PHIDCLASS_STEPPER: Phidget_DeviceClass = 18;
2107pub const Phidget_DeviceClass_PHIDCLASS_TEMPERATURESENSOR: Phidget_DeviceClass = 19;
2108pub const Phidget_DeviceClass_PHIDCLASS_TEXTLCD: Phidget_DeviceClass = 20;
2109pub const Phidget_DeviceClass_PHIDCLASS_VINT: Phidget_DeviceClass = 21;
2110pub type Phidget_DeviceClass = ::std::os::raw::c_uint;
2111pub const Phidget_ChannelClass_PHIDCHCLASS_NOTHING: Phidget_ChannelClass = 0;
2112pub const Phidget_ChannelClass_PHIDCHCLASS_ACCELEROMETER: Phidget_ChannelClass = 1;
2113pub const Phidget_ChannelClass_PHIDCHCLASS_BLDCMOTOR: Phidget_ChannelClass = 35;
2114pub const Phidget_ChannelClass_PHIDCHCLASS_CAPACITIVETOUCH: Phidget_ChannelClass = 14;
2115pub const Phidget_ChannelClass_PHIDCHCLASS_CURRENTINPUT: Phidget_ChannelClass = 2;
2116pub const Phidget_ChannelClass_PHIDCHCLASS_CURRENTOUTPUT: Phidget_ChannelClass = 38;
2117pub const Phidget_ChannelClass_PHIDCHCLASS_DATAADAPTER: Phidget_ChannelClass = 3;
2118pub const Phidget_ChannelClass_PHIDCHCLASS_DCMOTOR: Phidget_ChannelClass = 4;
2119pub const Phidget_ChannelClass_PHIDCHCLASS_DICTIONARY: Phidget_ChannelClass = 36;
2120pub const Phidget_ChannelClass_PHIDCHCLASS_DIGITALINPUT: Phidget_ChannelClass = 5;
2121pub const Phidget_ChannelClass_PHIDCHCLASS_DIGITALOUTPUT: Phidget_ChannelClass = 6;
2122pub const Phidget_ChannelClass_PHIDCHCLASS_DISTANCESENSOR: Phidget_ChannelClass = 7;
2123pub const Phidget_ChannelClass_PHIDCHCLASS_ENCODER: Phidget_ChannelClass = 8;
2124pub const Phidget_ChannelClass_PHIDCHCLASS_FIRMWAREUPGRADE: Phidget_ChannelClass = 32;
2125pub const Phidget_ChannelClass_PHIDCHCLASS_FREQUENCYCOUNTER: Phidget_ChannelClass = 9;
2126pub const Phidget_ChannelClass_PHIDCHCLASS_GENERIC: Phidget_ChannelClass = 33;
2127pub const Phidget_ChannelClass_PHIDCHCLASS_GPS: Phidget_ChannelClass = 10;
2128pub const Phidget_ChannelClass_PHIDCHCLASS_GYROSCOPE: Phidget_ChannelClass = 12;
2129pub const Phidget_ChannelClass_PHIDCHCLASS_HUB: Phidget_ChannelClass = 13;
2130pub const Phidget_ChannelClass_PHIDCHCLASS_HUMIDITYSENSOR: Phidget_ChannelClass = 15;
2131pub const Phidget_ChannelClass_PHIDCHCLASS_IR: Phidget_ChannelClass = 16;
2132pub const Phidget_ChannelClass_PHIDCHCLASS_LCD: Phidget_ChannelClass = 11;
2133pub const Phidget_ChannelClass_PHIDCHCLASS_LEDARRAY: Phidget_ChannelClass = 40;
2134pub const Phidget_ChannelClass_PHIDCHCLASS_LIGHTSENSOR: Phidget_ChannelClass = 17;
2135pub const Phidget_ChannelClass_PHIDCHCLASS_MAGNETOMETER: Phidget_ChannelClass = 18;
2136pub const Phidget_ChannelClass_PHIDCHCLASS_MESHDONGLE: Phidget_ChannelClass = 19;
2137pub const Phidget_ChannelClass_PHIDCHCLASS_MOTORPOSITIONCONTROLLER: Phidget_ChannelClass = 34;
2138pub const Phidget_ChannelClass_PHIDCHCLASS_MOTORVELOCITYCONTROLLER: Phidget_ChannelClass = 39;
2139pub const Phidget_ChannelClass_PHIDCHCLASS_PHSENSOR: Phidget_ChannelClass = 37;
2140pub const Phidget_ChannelClass_PHIDCHCLASS_POWERGUARD: Phidget_ChannelClass = 20;
2141pub const Phidget_ChannelClass_PHIDCHCLASS_PRESSURESENSOR: Phidget_ChannelClass = 21;
2142pub const Phidget_ChannelClass_PHIDCHCLASS_RCSERVO: Phidget_ChannelClass = 22;
2143pub const Phidget_ChannelClass_PHIDCHCLASS_RESISTANCEINPUT: Phidget_ChannelClass = 23;
2144pub const Phidget_ChannelClass_PHIDCHCLASS_RFID: Phidget_ChannelClass = 24;
2145pub const Phidget_ChannelClass_PHIDCHCLASS_SOUNDSENSOR: Phidget_ChannelClass = 25;
2146pub const Phidget_ChannelClass_PHIDCHCLASS_SPATIAL: Phidget_ChannelClass = 26;
2147pub const Phidget_ChannelClass_PHIDCHCLASS_STEPPER: Phidget_ChannelClass = 27;
2148pub const Phidget_ChannelClass_PHIDCHCLASS_TEMPERATURESENSOR: Phidget_ChannelClass = 28;
2149pub const Phidget_ChannelClass_PHIDCHCLASS_VOLTAGEINPUT: Phidget_ChannelClass = 29;
2150pub const Phidget_ChannelClass_PHIDCHCLASS_VOLTAGEOUTPUT: Phidget_ChannelClass = 30;
2151pub const Phidget_ChannelClass_PHIDCHCLASS_VOLTAGERATIOINPUT: Phidget_ChannelClass = 31;
2152pub type Phidget_ChannelClass = ::std::os::raw::c_uint;
2153pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_NONE: Phidget_ChannelSubclass = 1;
2154pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_DIGITALOUTPUT_DUTY_CYCLE: Phidget_ChannelSubclass =
2155 16;
2156pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_DIGITALOUTPUT_FREQUENCY: Phidget_ChannelSubclass =
2157 18;
2158pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_DIGITALOUTPUT_LED_DRIVER: Phidget_ChannelSubclass =
2159 17;
2160pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_ENCODER_MODE_SETTABLE: Phidget_ChannelSubclass =
2161 96;
2162pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_LCD_GRAPHIC: Phidget_ChannelSubclass = 80;
2163pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_LCD_TEXT: Phidget_ChannelSubclass = 81;
2164pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_SPATIAL_AHRS: Phidget_ChannelSubclass = 112;
2165pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_TEMPERATURESENSOR_RTD: Phidget_ChannelSubclass =
2166 32;
2167pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_TEMPERATURESENSOR_THERMOCOUPLE:
2168 Phidget_ChannelSubclass = 33;
2169pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_VOLTAGEINPUT_SENSOR_PORT: Phidget_ChannelSubclass =
2170 48;
2171pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_VOLTAGERATIOINPUT_BRIDGE: Phidget_ChannelSubclass =
2172 65;
2173pub const Phidget_ChannelSubclass_PHIDCHSUBCLASS_VOLTAGERATIOINPUT_SENSOR_PORT:
2174 Phidget_ChannelSubclass = 64;
2175pub type Phidget_ChannelSubclass = ::std::os::raw::c_uint;
2176pub const Phidget_MeshMode_MESHMODE_ROUTER: Phidget_MeshMode = 1;
2177pub const Phidget_MeshMode_MESHMODE_SLEEPYENDDEVICE: Phidget_MeshMode = 2;
2178pub type Phidget_MeshMode = ::std::os::raw::c_uint;
2179pub const Phidget_PowerSupply_POWER_SUPPLY_OFF: Phidget_PowerSupply = 1;
2180pub const Phidget_PowerSupply_POWER_SUPPLY_12V: Phidget_PowerSupply = 2;
2181pub const Phidget_PowerSupply_POWER_SUPPLY_24V: Phidget_PowerSupply = 3;
2182pub type Phidget_PowerSupply = ::std::os::raw::c_uint;
2183pub const Phidget_DataAdapterVoltage_DATAADAPTER_VOLTAGE_EXTERN: Phidget_DataAdapterVoltage = 1;
2184pub const Phidget_DataAdapterVoltage_DATAADAPTER_VOLTAGE_2_5V: Phidget_DataAdapterVoltage = 3;
2185pub const Phidget_DataAdapterVoltage_DATAADAPTER_VOLTAGE_3_3V: Phidget_DataAdapterVoltage = 4;
2186pub const Phidget_DataAdapterVoltage_DATAADAPTER_VOLTAGE_5_0V: Phidget_DataAdapterVoltage = 5;
2187pub type Phidget_DataAdapterVoltage = ::std::os::raw::c_uint;
2188pub const Phidget_RTDWireSetup_RTD_WIRE_SETUP_2WIRE: Phidget_RTDWireSetup = 1;
2189pub const Phidget_RTDWireSetup_RTD_WIRE_SETUP_3WIRE: Phidget_RTDWireSetup = 2;
2190pub const Phidget_RTDWireSetup_RTD_WIRE_SETUP_4WIRE: Phidget_RTDWireSetup = 3;
2191pub type Phidget_RTDWireSetup = ::std::os::raw::c_uint;
2192pub const Phidget_InputMode_INPUT_MODE_NPN: Phidget_InputMode = 1;
2193pub const Phidget_InputMode_INPUT_MODE_PNP: Phidget_InputMode = 2;
2194pub const Phidget_InputMode_INPUT_MODE_FLOATING: Phidget_InputMode = 3;
2195pub const Phidget_InputMode_INPUT_MODE_PULLUP: Phidget_InputMode = 4;
2196pub type Phidget_InputMode = ::std::os::raw::c_uint;
2197pub const Phidget_FanMode_FAN_MODE_OFF: Phidget_FanMode = 1;
2198pub const Phidget_FanMode_FAN_MODE_ON: Phidget_FanMode = 2;
2199pub const Phidget_FanMode_FAN_MODE_AUTO: Phidget_FanMode = 3;
2200pub type Phidget_FanMode = ::std::os::raw::c_uint;
2201pub const Phidget_DriveMode_DRIVE_MODE_COAST: Phidget_DriveMode = 1;
2202pub const Phidget_DriveMode_DRIVE_MODE_FORCED: Phidget_DriveMode = 2;
2203pub type Phidget_DriveMode = ::std::os::raw::c_uint;
2204pub const Phidget_PositionType_POSITION_TYPE_ENCODER: Phidget_PositionType = 1;
2205pub const Phidget_PositionType_POSITION_TYPE_HALL_SENSOR: Phidget_PositionType = 2;
2206pub type Phidget_PositionType = ::std::os::raw::c_uint;
2207pub const Phidget_SpatialPrecision_SPATIAL_PRECISION_HYBRID: Phidget_SpatialPrecision = 0;
2208pub const Phidget_SpatialPrecision_SPATIAL_PRECISION_HIGH: Phidget_SpatialPrecision = 1;
2209pub const Phidget_SpatialPrecision_SPATIAL_PRECISION_LOW: Phidget_SpatialPrecision = 2;
2210pub type Phidget_SpatialPrecision = ::std::os::raw::c_uint;
2211pub const Phidget_Unit_PHIDUNIT_NONE: Phidget_Unit = 0;
2212pub const Phidget_Unit_PHIDUNIT_BOOLEAN: Phidget_Unit = 1;
2213pub const Phidget_Unit_PHIDUNIT_PERCENT: Phidget_Unit = 2;
2214pub const Phidget_Unit_PHIDUNIT_DECIBEL: Phidget_Unit = 3;
2215pub const Phidget_Unit_PHIDUNIT_MILLIMETER: Phidget_Unit = 4;
2216pub const Phidget_Unit_PHIDUNIT_CENTIMETER: Phidget_Unit = 5;
2217pub const Phidget_Unit_PHIDUNIT_METER: Phidget_Unit = 6;
2218pub const Phidget_Unit_PHIDUNIT_GRAM: Phidget_Unit = 7;
2219pub const Phidget_Unit_PHIDUNIT_KILOGRAM: Phidget_Unit = 8;
2220pub const Phidget_Unit_PHIDUNIT_MILLIAMPERE: Phidget_Unit = 9;
2221pub const Phidget_Unit_PHIDUNIT_AMPERE: Phidget_Unit = 10;
2222pub const Phidget_Unit_PHIDUNIT_KILOPASCAL: Phidget_Unit = 11;
2223pub const Phidget_Unit_PHIDUNIT_VOLT: Phidget_Unit = 12;
2224pub const Phidget_Unit_PHIDUNIT_DEGREE_CELCIUS: Phidget_Unit = 13;
2225pub const Phidget_Unit_PHIDUNIT_LUX: Phidget_Unit = 14;
2226pub const Phidget_Unit_PHIDUNIT_GAUSS: Phidget_Unit = 15;
2227pub const Phidget_Unit_PHIDUNIT_PH: Phidget_Unit = 16;
2228pub const Phidget_Unit_PHIDUNIT_WATT: Phidget_Unit = 17;
2229pub type Phidget_Unit = ::std::os::raw::c_uint;
2230#[repr(C)]
2231#[derive(Debug, Copy, Clone)]
2232pub struct Phidget_UnitInfo {
2233 pub unit: Phidget_Unit,
2234 pub name: *const ::std::os::raw::c_char,
2235 pub symbol: *const ::std::os::raw::c_char,
2236}
2237#[test]
2238fn bindgen_test_layout_Phidget_UnitInfo() {
2239 const UNINIT: ::std::mem::MaybeUninit<Phidget_UnitInfo> = ::std::mem::MaybeUninit::uninit();
2240 let ptr = UNINIT.as_ptr();
2241 assert_eq!(
2242 ::std::mem::size_of::<Phidget_UnitInfo>(),
2243 24usize,
2244 "Size of Phidget_UnitInfo"
2245 );
2246 assert_eq!(
2247 ::std::mem::align_of::<Phidget_UnitInfo>(),
2248 8usize,
2249 "Alignment of Phidget_UnitInfo"
2250 );
2251 assert_eq!(
2252 unsafe { ::std::ptr::addr_of!((*ptr).unit) as usize - ptr as usize },
2253 0usize,
2254 "Offset of field: Phidget_UnitInfo::unit"
2255 );
2256 assert_eq!(
2257 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
2258 8usize,
2259 "Offset of field: Phidget_UnitInfo::name"
2260 );
2261 assert_eq!(
2262 unsafe { ::std::ptr::addr_of!((*ptr).symbol) as usize - ptr as usize },
2263 16usize,
2264 "Offset of field: Phidget_UnitInfo::symbol"
2265 );
2266}
2267pub type Phidget_UnitInfoHandle = *mut Phidget_UnitInfo;
2268pub const PhidgetServerType_PHIDGETSERVER_NONE: PhidgetServerType = 0;
2269pub const PhidgetServerType_PHIDGETSERVER_DEVICELISTENER: PhidgetServerType = 1;
2270pub const PhidgetServerType_PHIDGETSERVER_DEVICE: PhidgetServerType = 2;
2271pub const PhidgetServerType_PHIDGETSERVER_DEVICEREMOTE: PhidgetServerType = 3;
2272pub const PhidgetServerType_PHIDGETSERVER_WWWLISTENER: PhidgetServerType = 4;
2273pub const PhidgetServerType_PHIDGETSERVER_WWW: PhidgetServerType = 5;
2274pub const PhidgetServerType_PHIDGETSERVER_WWWREMOTE: PhidgetServerType = 6;
2275pub const PhidgetServerType_PHIDGETSERVER_SBC: PhidgetServerType = 7;
2276pub type PhidgetServerType = ::std::os::raw::c_uint;
2277#[repr(C)]
2278#[derive(Debug, Copy, Clone)]
2279pub struct PhidgetServer {
2280 pub name: *const ::std::os::raw::c_char,
2281 pub stype: *const ::std::os::raw::c_char,
2282 pub type_: PhidgetServerType,
2283 pub flags: ::std::os::raw::c_int,
2284 pub addr: *const ::std::os::raw::c_char,
2285 pub host: *const ::std::os::raw::c_char,
2286 pub port: ::std::os::raw::c_int,
2287}
2288#[test]
2289fn bindgen_test_layout_PhidgetServer() {
2290 const UNINIT: ::std::mem::MaybeUninit<PhidgetServer> = ::std::mem::MaybeUninit::uninit();
2291 let ptr = UNINIT.as_ptr();
2292 assert_eq!(
2293 ::std::mem::size_of::<PhidgetServer>(),
2294 48usize,
2295 "Size of PhidgetServer"
2296 );
2297 assert_eq!(
2298 ::std::mem::align_of::<PhidgetServer>(),
2299 8usize,
2300 "Alignment of PhidgetServer"
2301 );
2302 assert_eq!(
2303 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
2304 0usize,
2305 "Offset of field: PhidgetServer::name"
2306 );
2307 assert_eq!(
2308 unsafe { ::std::ptr::addr_of!((*ptr).stype) as usize - ptr as usize },
2309 8usize,
2310 "Offset of field: PhidgetServer::stype"
2311 );
2312 assert_eq!(
2313 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
2314 16usize,
2315 "Offset of field: PhidgetServer::type_"
2316 );
2317 assert_eq!(
2318 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2319 20usize,
2320 "Offset of field: PhidgetServer::flags"
2321 );
2322 assert_eq!(
2323 unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
2324 24usize,
2325 "Offset of field: PhidgetServer::addr"
2326 );
2327 assert_eq!(
2328 unsafe { ::std::ptr::addr_of!((*ptr).host) as usize - ptr as usize },
2329 32usize,
2330 "Offset of field: PhidgetServer::host"
2331 );
2332 assert_eq!(
2333 unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
2334 40usize,
2335 "Offset of field: PhidgetServer::port"
2336 );
2337}
2338pub type PhidgetServerHandle = *mut PhidgetServer;
2339pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_1: PhidgetVoltageRatioInput_BridgeGain =
2340 1;
2341pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_2: PhidgetVoltageRatioInput_BridgeGain =
2342 2;
2343pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_4: PhidgetVoltageRatioInput_BridgeGain =
2344 3;
2345pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_8: PhidgetVoltageRatioInput_BridgeGain =
2346 4;
2347pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_16: PhidgetVoltageRatioInput_BridgeGain =
2348 5;
2349pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_32: PhidgetVoltageRatioInput_BridgeGain =
2350 6;
2351pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_64: PhidgetVoltageRatioInput_BridgeGain =
2352 7;
2353pub const PhidgetVoltageRatioInput_BridgeGain_BRIDGE_GAIN_128: PhidgetVoltageRatioInput_BridgeGain =
2354 8;
2355pub type PhidgetVoltageRatioInput_BridgeGain = ::std::os::raw::c_uint;
2356pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_VOLTAGERATIO:
2357 PhidgetVoltageRatioInput_SensorType = 0;
2358pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1101_SHARP_2D120X:
2359 PhidgetVoltageRatioInput_SensorType = 11011;
2360pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1101_SHARP_2Y0A21:
2361 PhidgetVoltageRatioInput_SensorType = 11012;
2362pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1101_SHARP_2Y0A02:
2363 PhidgetVoltageRatioInput_SensorType = 11013;
2364pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1102:
2365 PhidgetVoltageRatioInput_SensorType = 11020;
2366pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1103:
2367 PhidgetVoltageRatioInput_SensorType = 11030;
2368pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1104:
2369 PhidgetVoltageRatioInput_SensorType = 11040;
2370pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1105:
2371 PhidgetVoltageRatioInput_SensorType = 11050;
2372pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1106:
2373 PhidgetVoltageRatioInput_SensorType = 11060;
2374pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1107:
2375 PhidgetVoltageRatioInput_SensorType = 11070;
2376pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1108:
2377 PhidgetVoltageRatioInput_SensorType = 11080;
2378pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1109:
2379 PhidgetVoltageRatioInput_SensorType = 11090;
2380pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1110:
2381 PhidgetVoltageRatioInput_SensorType = 11100;
2382pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1111:
2383 PhidgetVoltageRatioInput_SensorType = 11110;
2384pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1112:
2385 PhidgetVoltageRatioInput_SensorType = 11120;
2386pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1113:
2387 PhidgetVoltageRatioInput_SensorType = 11130;
2388pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1115:
2389 PhidgetVoltageRatioInput_SensorType = 11150;
2390pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1116:
2391 PhidgetVoltageRatioInput_SensorType = 11160;
2392pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1118_AC:
2393 PhidgetVoltageRatioInput_SensorType = 11181;
2394pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1118_DC:
2395 PhidgetVoltageRatioInput_SensorType = 11182;
2396pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1119_AC:
2397 PhidgetVoltageRatioInput_SensorType = 11191;
2398pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1119_DC:
2399 PhidgetVoltageRatioInput_SensorType = 11192;
2400pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1120:
2401 PhidgetVoltageRatioInput_SensorType = 11200;
2402pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1121:
2403 PhidgetVoltageRatioInput_SensorType = 11210;
2404pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1122_AC:
2405 PhidgetVoltageRatioInput_SensorType = 11221;
2406pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1122_DC:
2407 PhidgetVoltageRatioInput_SensorType = 11222;
2408pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1124:
2409 PhidgetVoltageRatioInput_SensorType = 11240;
2410pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1125_HUMIDITY:
2411 PhidgetVoltageRatioInput_SensorType = 11251;
2412pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1125_TEMPERATURE:
2413 PhidgetVoltageRatioInput_SensorType = 11252;
2414pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1126:
2415 PhidgetVoltageRatioInput_SensorType = 11260;
2416pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1128:
2417 PhidgetVoltageRatioInput_SensorType = 11280;
2418pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1129:
2419 PhidgetVoltageRatioInput_SensorType = 11290;
2420pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1131:
2421 PhidgetVoltageRatioInput_SensorType = 11310;
2422pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1134:
2423 PhidgetVoltageRatioInput_SensorType = 11340;
2424pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1136:
2425 PhidgetVoltageRatioInput_SensorType = 11360;
2426pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1137:
2427 PhidgetVoltageRatioInput_SensorType = 11370;
2428pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1138:
2429 PhidgetVoltageRatioInput_SensorType = 11380;
2430pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1139:
2431 PhidgetVoltageRatioInput_SensorType = 11390;
2432pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1140:
2433 PhidgetVoltageRatioInput_SensorType = 11400;
2434pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1141:
2435 PhidgetVoltageRatioInput_SensorType = 11410;
2436pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_1146:
2437 PhidgetVoltageRatioInput_SensorType = 11460;
2438pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3120:
2439 PhidgetVoltageRatioInput_SensorType = 31200;
2440pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3121:
2441 PhidgetVoltageRatioInput_SensorType = 31210;
2442pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3122:
2443 PhidgetVoltageRatioInput_SensorType = 31220;
2444pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3123:
2445 PhidgetVoltageRatioInput_SensorType = 31230;
2446pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3130:
2447 PhidgetVoltageRatioInput_SensorType = 31300;
2448pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3520:
2449 PhidgetVoltageRatioInput_SensorType = 35200;
2450pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3521:
2451 PhidgetVoltageRatioInput_SensorType = 35210;
2452pub const PhidgetVoltageRatioInput_SensorType_SENSOR_TYPE_3522:
2453 PhidgetVoltageRatioInput_SensorType = 35220;
2454pub type PhidgetVoltageRatioInput_SensorType = ::std::os::raw::c_uint;
2455pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_1_7V:
2456 PhidgetDigitalOutput_LEDForwardVoltage = 1;
2457pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_2_75V:
2458 PhidgetDigitalOutput_LEDForwardVoltage = 2;
2459pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_3_2V:
2460 PhidgetDigitalOutput_LEDForwardVoltage = 3;
2461pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_3_9V:
2462 PhidgetDigitalOutput_LEDForwardVoltage = 4;
2463pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_4_0V:
2464 PhidgetDigitalOutput_LEDForwardVoltage = 5;
2465pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_4_8V:
2466 PhidgetDigitalOutput_LEDForwardVoltage = 6;
2467pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_5_0V:
2468 PhidgetDigitalOutput_LEDForwardVoltage = 7;
2469pub const PhidgetDigitalOutput_LEDForwardVoltage_LED_FORWARD_VOLTAGE_5_6V:
2470 PhidgetDigitalOutput_LEDForwardVoltage = 8;
2471pub type PhidgetDigitalOutput_LEDForwardVoltage = ::std::os::raw::c_uint;
2472pub const PhidgetRCServo_Voltage_RCSERVO_VOLTAGE_5V: PhidgetRCServo_Voltage = 1;
2473pub const PhidgetRCServo_Voltage_RCSERVO_VOLTAGE_6V: PhidgetRCServo_Voltage = 2;
2474pub const PhidgetRCServo_Voltage_RCSERVO_VOLTAGE_7_4V: PhidgetRCServo_Voltage = 3;
2475pub type PhidgetRCServo_Voltage = ::std::os::raw::c_uint;
2476pub const PhidgetVoltageOutput_VoltageOutputRange_VOLTAGE_OUTPUT_RANGE_10V:
2477 PhidgetVoltageOutput_VoltageOutputRange = 1;
2478pub const PhidgetVoltageOutput_VoltageOutputRange_VOLTAGE_OUTPUT_RANGE_5V:
2479 PhidgetVoltageOutput_VoltageOutputRange = 2;
2480pub type PhidgetVoltageOutput_VoltageOutputRange = ::std::os::raw::c_uint;
2481pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_10mV: PhidgetVoltageInput_VoltageRange = 1;
2482pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_40mV: PhidgetVoltageInput_VoltageRange = 2;
2483pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_200mV: PhidgetVoltageInput_VoltageRange =
2484 3;
2485pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_312_5mV: PhidgetVoltageInput_VoltageRange =
2486 4;
2487pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_400mV: PhidgetVoltageInput_VoltageRange =
2488 5;
2489pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_1000mV: PhidgetVoltageInput_VoltageRange =
2490 6;
2491pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_2V: PhidgetVoltageInput_VoltageRange = 7;
2492pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_5V: PhidgetVoltageInput_VoltageRange = 8;
2493pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_15V: PhidgetVoltageInput_VoltageRange = 9;
2494pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_40V: PhidgetVoltageInput_VoltageRange = 10;
2495pub const PhidgetVoltageInput_VoltageRange_VOLTAGE_RANGE_AUTO: PhidgetVoltageInput_VoltageRange =
2496 11;
2497pub type PhidgetVoltageInput_VoltageRange = ::std::os::raw::c_uint;
2498pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_VOLTAGE: PhidgetVoltageInput_SensorType = 0;
2499pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1114: PhidgetVoltageInput_SensorType = 11140;
2500pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1117: PhidgetVoltageInput_SensorType = 11170;
2501pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1123: PhidgetVoltageInput_SensorType = 11230;
2502pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1127: PhidgetVoltageInput_SensorType = 11270;
2503pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1130_PH: PhidgetVoltageInput_SensorType =
2504 11301;
2505pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1130_ORP: PhidgetVoltageInput_SensorType =
2506 11302;
2507pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1132: PhidgetVoltageInput_SensorType = 11320;
2508pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1133: PhidgetVoltageInput_SensorType = 11330;
2509pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1135: PhidgetVoltageInput_SensorType = 11350;
2510pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1142: PhidgetVoltageInput_SensorType = 11420;
2511pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_1143: PhidgetVoltageInput_SensorType = 11430;
2512pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3500: PhidgetVoltageInput_SensorType = 35000;
2513pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3501: PhidgetVoltageInput_SensorType = 35010;
2514pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3502: PhidgetVoltageInput_SensorType = 35020;
2515pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3503: PhidgetVoltageInput_SensorType = 35030;
2516pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3507: PhidgetVoltageInput_SensorType = 35070;
2517pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3508: PhidgetVoltageInput_SensorType = 35080;
2518pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3509: PhidgetVoltageInput_SensorType = 35090;
2519pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3510: PhidgetVoltageInput_SensorType = 35100;
2520pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3511: PhidgetVoltageInput_SensorType = 35110;
2521pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3512: PhidgetVoltageInput_SensorType = 35120;
2522pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3513: PhidgetVoltageInput_SensorType = 35130;
2523pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3514: PhidgetVoltageInput_SensorType = 35140;
2524pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3515: PhidgetVoltageInput_SensorType = 35150;
2525pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3516: PhidgetVoltageInput_SensorType = 35160;
2526pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3517: PhidgetVoltageInput_SensorType = 35170;
2527pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3518: PhidgetVoltageInput_SensorType = 35180;
2528pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3519: PhidgetVoltageInput_SensorType = 35190;
2529pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3584: PhidgetVoltageInput_SensorType = 35840;
2530pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3585: PhidgetVoltageInput_SensorType = 35850;
2531pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3586: PhidgetVoltageInput_SensorType = 35860;
2532pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3587: PhidgetVoltageInput_SensorType = 35870;
2533pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3588: PhidgetVoltageInput_SensorType = 35880;
2534pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_3589: PhidgetVoltageInput_SensorType = 35890;
2535pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_MOT2002_LOW: PhidgetVoltageInput_SensorType =
2536 20020;
2537pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_MOT2002_MED: PhidgetVoltageInput_SensorType =
2538 20021;
2539pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_MOT2002_HIGH: PhidgetVoltageInput_SensorType =
2540 20022;
2541pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_VCP4114: PhidgetVoltageInput_SensorType =
2542 41140;
2543pub const PhidgetVoltageInput_SensorType_SENSOR_TYPE_VCP4115: PhidgetVoltageInput_SensorType =
2544 41150;
2545pub type PhidgetVoltageInput_SensorType = ::std::os::raw::c_uint;
2546pub const PhidgetRFID_Protocol_PROTOCOL_EM4100: PhidgetRFID_Protocol = 1;
2547pub const PhidgetRFID_Protocol_PROTOCOL_ISO11785_FDX_B: PhidgetRFID_Protocol = 2;
2548pub const PhidgetRFID_Protocol_PROTOCOL_PHIDGETS: PhidgetRFID_Protocol = 3;
2549pub const PhidgetRFID_Protocol_PROTOCOL_HID_GENERIC: PhidgetRFID_Protocol = 4;
2550pub const PhidgetRFID_Protocol_PROTOCOL_HID_H10301: PhidgetRFID_Protocol = 5;
2551pub type PhidgetRFID_Protocol = ::std::os::raw::c_uint;
2552pub const PhidgetRFID_Chipset_CHIPSET_T5577: PhidgetRFID_Chipset = 1;
2553pub const PhidgetRFID_Chipset_CHIPSET_EM4305: PhidgetRFID_Chipset = 2;
2554pub type PhidgetRFID_Chipset = ::std::os::raw::c_uint;
2555#[repr(C)]
2556#[derive(Debug, Copy, Clone)]
2557pub struct PhidgetGPS_Time {
2558 pub tm_ms: i16,
2559 pub tm_sec: i16,
2560 pub tm_min: i16,
2561 pub tm_hour: i16,
2562}
2563#[test]
2564fn bindgen_test_layout_PhidgetGPS_Time() {
2565 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_Time> = ::std::mem::MaybeUninit::uninit();
2566 let ptr = UNINIT.as_ptr();
2567 assert_eq!(
2568 ::std::mem::size_of::<PhidgetGPS_Time>(),
2569 8usize,
2570 "Size of PhidgetGPS_Time"
2571 );
2572 assert_eq!(
2573 ::std::mem::align_of::<PhidgetGPS_Time>(),
2574 2usize,
2575 "Alignment of PhidgetGPS_Time"
2576 );
2577 assert_eq!(
2578 unsafe { ::std::ptr::addr_of!((*ptr).tm_ms) as usize - ptr as usize },
2579 0usize,
2580 "Offset of field: PhidgetGPS_Time::tm_ms"
2581 );
2582 assert_eq!(
2583 unsafe { ::std::ptr::addr_of!((*ptr).tm_sec) as usize - ptr as usize },
2584 2usize,
2585 "Offset of field: PhidgetGPS_Time::tm_sec"
2586 );
2587 assert_eq!(
2588 unsafe { ::std::ptr::addr_of!((*ptr).tm_min) as usize - ptr as usize },
2589 4usize,
2590 "Offset of field: PhidgetGPS_Time::tm_min"
2591 );
2592 assert_eq!(
2593 unsafe { ::std::ptr::addr_of!((*ptr).tm_hour) as usize - ptr as usize },
2594 6usize,
2595 "Offset of field: PhidgetGPS_Time::tm_hour"
2596 );
2597}
2598pub type PhidgetGPS_TimeHandle = *mut PhidgetGPS_Time;
2599#[repr(C)]
2600#[derive(Debug, Copy, Clone)]
2601pub struct PhidgetGPS_Date {
2602 pub tm_mday: i16,
2603 pub tm_mon: i16,
2604 pub tm_year: i16,
2605}
2606#[test]
2607fn bindgen_test_layout_PhidgetGPS_Date() {
2608 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_Date> = ::std::mem::MaybeUninit::uninit();
2609 let ptr = UNINIT.as_ptr();
2610 assert_eq!(
2611 ::std::mem::size_of::<PhidgetGPS_Date>(),
2612 6usize,
2613 "Size of PhidgetGPS_Date"
2614 );
2615 assert_eq!(
2616 ::std::mem::align_of::<PhidgetGPS_Date>(),
2617 2usize,
2618 "Alignment of PhidgetGPS_Date"
2619 );
2620 assert_eq!(
2621 unsafe { ::std::ptr::addr_of!((*ptr).tm_mday) as usize - ptr as usize },
2622 0usize,
2623 "Offset of field: PhidgetGPS_Date::tm_mday"
2624 );
2625 assert_eq!(
2626 unsafe { ::std::ptr::addr_of!((*ptr).tm_mon) as usize - ptr as usize },
2627 2usize,
2628 "Offset of field: PhidgetGPS_Date::tm_mon"
2629 );
2630 assert_eq!(
2631 unsafe { ::std::ptr::addr_of!((*ptr).tm_year) as usize - ptr as usize },
2632 4usize,
2633 "Offset of field: PhidgetGPS_Date::tm_year"
2634 );
2635}
2636pub type PhidgetGPS_DateHandle = *mut PhidgetGPS_Date;
2637#[repr(C)]
2638#[derive(Debug, Copy, Clone)]
2639pub struct PhidgetGPS_GPGGA {
2640 pub latitude: f64,
2641 pub longitude: f64,
2642 pub fixQuality: i16,
2643 pub numSatellites: i16,
2644 pub horizontalDilution: f64,
2645 pub altitude: f64,
2646 pub heightOfGeoid: f64,
2647}
2648#[test]
2649fn bindgen_test_layout_PhidgetGPS_GPGGA() {
2650 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_GPGGA> = ::std::mem::MaybeUninit::uninit();
2651 let ptr = UNINIT.as_ptr();
2652 assert_eq!(
2653 ::std::mem::size_of::<PhidgetGPS_GPGGA>(),
2654 48usize,
2655 "Size of PhidgetGPS_GPGGA"
2656 );
2657 assert_eq!(
2658 ::std::mem::align_of::<PhidgetGPS_GPGGA>(),
2659 8usize,
2660 "Alignment of PhidgetGPS_GPGGA"
2661 );
2662 assert_eq!(
2663 unsafe { ::std::ptr::addr_of!((*ptr).latitude) as usize - ptr as usize },
2664 0usize,
2665 "Offset of field: PhidgetGPS_GPGGA::latitude"
2666 );
2667 assert_eq!(
2668 unsafe { ::std::ptr::addr_of!((*ptr).longitude) as usize - ptr as usize },
2669 8usize,
2670 "Offset of field: PhidgetGPS_GPGGA::longitude"
2671 );
2672 assert_eq!(
2673 unsafe { ::std::ptr::addr_of!((*ptr).fixQuality) as usize - ptr as usize },
2674 16usize,
2675 "Offset of field: PhidgetGPS_GPGGA::fixQuality"
2676 );
2677 assert_eq!(
2678 unsafe { ::std::ptr::addr_of!((*ptr).numSatellites) as usize - ptr as usize },
2679 18usize,
2680 "Offset of field: PhidgetGPS_GPGGA::numSatellites"
2681 );
2682 assert_eq!(
2683 unsafe { ::std::ptr::addr_of!((*ptr).horizontalDilution) as usize - ptr as usize },
2684 24usize,
2685 "Offset of field: PhidgetGPS_GPGGA::horizontalDilution"
2686 );
2687 assert_eq!(
2688 unsafe { ::std::ptr::addr_of!((*ptr).altitude) as usize - ptr as usize },
2689 32usize,
2690 "Offset of field: PhidgetGPS_GPGGA::altitude"
2691 );
2692 assert_eq!(
2693 unsafe { ::std::ptr::addr_of!((*ptr).heightOfGeoid) as usize - ptr as usize },
2694 40usize,
2695 "Offset of field: PhidgetGPS_GPGGA::heightOfGeoid"
2696 );
2697}
2698pub type PhidgetGPS_GPGGAHandle = *mut PhidgetGPS_GPGGA;
2699#[repr(C)]
2700#[derive(Debug, Copy, Clone)]
2701pub struct PhidgetGPS_GPGSA {
2702 pub mode: ::std::os::raw::c_char,
2703 pub fixType: i16,
2704 pub satUsed: [i16; 12usize],
2705 pub posnDilution: f64,
2706 pub horizDilution: f64,
2707 pub vertDilution: f64,
2708}
2709#[test]
2710fn bindgen_test_layout_PhidgetGPS_GPGSA() {
2711 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_GPGSA> = ::std::mem::MaybeUninit::uninit();
2712 let ptr = UNINIT.as_ptr();
2713 assert_eq!(
2714 ::std::mem::size_of::<PhidgetGPS_GPGSA>(),
2715 56usize,
2716 "Size of PhidgetGPS_GPGSA"
2717 );
2718 assert_eq!(
2719 ::std::mem::align_of::<PhidgetGPS_GPGSA>(),
2720 8usize,
2721 "Alignment of PhidgetGPS_GPGSA"
2722 );
2723 assert_eq!(
2724 unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
2725 0usize,
2726 "Offset of field: PhidgetGPS_GPGSA::mode"
2727 );
2728 assert_eq!(
2729 unsafe { ::std::ptr::addr_of!((*ptr).fixType) as usize - ptr as usize },
2730 2usize,
2731 "Offset of field: PhidgetGPS_GPGSA::fixType"
2732 );
2733 assert_eq!(
2734 unsafe { ::std::ptr::addr_of!((*ptr).satUsed) as usize - ptr as usize },
2735 4usize,
2736 "Offset of field: PhidgetGPS_GPGSA::satUsed"
2737 );
2738 assert_eq!(
2739 unsafe { ::std::ptr::addr_of!((*ptr).posnDilution) as usize - ptr as usize },
2740 32usize,
2741 "Offset of field: PhidgetGPS_GPGSA::posnDilution"
2742 );
2743 assert_eq!(
2744 unsafe { ::std::ptr::addr_of!((*ptr).horizDilution) as usize - ptr as usize },
2745 40usize,
2746 "Offset of field: PhidgetGPS_GPGSA::horizDilution"
2747 );
2748 assert_eq!(
2749 unsafe { ::std::ptr::addr_of!((*ptr).vertDilution) as usize - ptr as usize },
2750 48usize,
2751 "Offset of field: PhidgetGPS_GPGSA::vertDilution"
2752 );
2753}
2754pub type PhidgetGPS_GPGSAHandle = *mut PhidgetGPS_GPGSA;
2755#[repr(C)]
2756#[derive(Debug, Copy, Clone)]
2757pub struct PhidgetGPS_GPRMC {
2758 pub status: ::std::os::raw::c_char,
2759 pub latitude: f64,
2760 pub longitude: f64,
2761 pub speedKnots: f64,
2762 pub heading: f64,
2763 pub magneticVariation: f64,
2764 pub mode: ::std::os::raw::c_char,
2765}
2766#[test]
2767fn bindgen_test_layout_PhidgetGPS_GPRMC() {
2768 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_GPRMC> = ::std::mem::MaybeUninit::uninit();
2769 let ptr = UNINIT.as_ptr();
2770 assert_eq!(
2771 ::std::mem::size_of::<PhidgetGPS_GPRMC>(),
2772 56usize,
2773 "Size of PhidgetGPS_GPRMC"
2774 );
2775 assert_eq!(
2776 ::std::mem::align_of::<PhidgetGPS_GPRMC>(),
2777 8usize,
2778 "Alignment of PhidgetGPS_GPRMC"
2779 );
2780 assert_eq!(
2781 unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
2782 0usize,
2783 "Offset of field: PhidgetGPS_GPRMC::status"
2784 );
2785 assert_eq!(
2786 unsafe { ::std::ptr::addr_of!((*ptr).latitude) as usize - ptr as usize },
2787 8usize,
2788 "Offset of field: PhidgetGPS_GPRMC::latitude"
2789 );
2790 assert_eq!(
2791 unsafe { ::std::ptr::addr_of!((*ptr).longitude) as usize - ptr as usize },
2792 16usize,
2793 "Offset of field: PhidgetGPS_GPRMC::longitude"
2794 );
2795 assert_eq!(
2796 unsafe { ::std::ptr::addr_of!((*ptr).speedKnots) as usize - ptr as usize },
2797 24usize,
2798 "Offset of field: PhidgetGPS_GPRMC::speedKnots"
2799 );
2800 assert_eq!(
2801 unsafe { ::std::ptr::addr_of!((*ptr).heading) as usize - ptr as usize },
2802 32usize,
2803 "Offset of field: PhidgetGPS_GPRMC::heading"
2804 );
2805 assert_eq!(
2806 unsafe { ::std::ptr::addr_of!((*ptr).magneticVariation) as usize - ptr as usize },
2807 40usize,
2808 "Offset of field: PhidgetGPS_GPRMC::magneticVariation"
2809 );
2810 assert_eq!(
2811 unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
2812 48usize,
2813 "Offset of field: PhidgetGPS_GPRMC::mode"
2814 );
2815}
2816pub type PhidgetGPS_GPRMCHandle = *mut PhidgetGPS_GPRMC;
2817#[repr(C)]
2818#[derive(Debug, Copy, Clone)]
2819pub struct PhidgetGPS_GPVTG {
2820 pub trueHeading: f64,
2821 pub magneticHeading: f64,
2822 pub speedKnots: f64,
2823 pub speed: f64,
2824 pub mode: ::std::os::raw::c_char,
2825}
2826#[test]
2827fn bindgen_test_layout_PhidgetGPS_GPVTG() {
2828 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_GPVTG> = ::std::mem::MaybeUninit::uninit();
2829 let ptr = UNINIT.as_ptr();
2830 assert_eq!(
2831 ::std::mem::size_of::<PhidgetGPS_GPVTG>(),
2832 40usize,
2833 "Size of PhidgetGPS_GPVTG"
2834 );
2835 assert_eq!(
2836 ::std::mem::align_of::<PhidgetGPS_GPVTG>(),
2837 8usize,
2838 "Alignment of PhidgetGPS_GPVTG"
2839 );
2840 assert_eq!(
2841 unsafe { ::std::ptr::addr_of!((*ptr).trueHeading) as usize - ptr as usize },
2842 0usize,
2843 "Offset of field: PhidgetGPS_GPVTG::trueHeading"
2844 );
2845 assert_eq!(
2846 unsafe { ::std::ptr::addr_of!((*ptr).magneticHeading) as usize - ptr as usize },
2847 8usize,
2848 "Offset of field: PhidgetGPS_GPVTG::magneticHeading"
2849 );
2850 assert_eq!(
2851 unsafe { ::std::ptr::addr_of!((*ptr).speedKnots) as usize - ptr as usize },
2852 16usize,
2853 "Offset of field: PhidgetGPS_GPVTG::speedKnots"
2854 );
2855 assert_eq!(
2856 unsafe { ::std::ptr::addr_of!((*ptr).speed) as usize - ptr as usize },
2857 24usize,
2858 "Offset of field: PhidgetGPS_GPVTG::speed"
2859 );
2860 assert_eq!(
2861 unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
2862 32usize,
2863 "Offset of field: PhidgetGPS_GPVTG::mode"
2864 );
2865}
2866pub type PhidgetGPS_GPVTGHandle = *mut PhidgetGPS_GPVTG;
2867#[repr(C)]
2868#[derive(Debug, Copy, Clone)]
2869pub struct PhidgetGPS_NMEAData {
2870 pub GGA: PhidgetGPS_GPGGA,
2871 pub GSA: PhidgetGPS_GPGSA,
2872 pub RMC: PhidgetGPS_GPRMC,
2873 pub VTG: PhidgetGPS_GPVTG,
2874}
2875#[test]
2876fn bindgen_test_layout_PhidgetGPS_NMEAData() {
2877 const UNINIT: ::std::mem::MaybeUninit<PhidgetGPS_NMEAData> = ::std::mem::MaybeUninit::uninit();
2878 let ptr = UNINIT.as_ptr();
2879 assert_eq!(
2880 ::std::mem::size_of::<PhidgetGPS_NMEAData>(),
2881 200usize,
2882 "Size of PhidgetGPS_NMEAData"
2883 );
2884 assert_eq!(
2885 ::std::mem::align_of::<PhidgetGPS_NMEAData>(),
2886 8usize,
2887 "Alignment of PhidgetGPS_NMEAData"
2888 );
2889 assert_eq!(
2890 unsafe { ::std::ptr::addr_of!((*ptr).GGA) as usize - ptr as usize },
2891 0usize,
2892 "Offset of field: PhidgetGPS_NMEAData::GGA"
2893 );
2894 assert_eq!(
2895 unsafe { ::std::ptr::addr_of!((*ptr).GSA) as usize - ptr as usize },
2896 48usize,
2897 "Offset of field: PhidgetGPS_NMEAData::GSA"
2898 );
2899 assert_eq!(
2900 unsafe { ::std::ptr::addr_of!((*ptr).RMC) as usize - ptr as usize },
2901 104usize,
2902 "Offset of field: PhidgetGPS_NMEAData::RMC"
2903 );
2904 assert_eq!(
2905 unsafe { ::std::ptr::addr_of!((*ptr).VTG) as usize - ptr as usize },
2906 160usize,
2907 "Offset of field: PhidgetGPS_NMEAData::VTG"
2908 );
2909}
2910pub type PhidgetGPS_NMEADataHandle = *mut PhidgetGPS_NMEAData;
2911pub const Phidget_SpatialAlgorithm_SPATIAL_ALGORITHM_NONE: Phidget_SpatialAlgorithm = 0;
2912pub const Phidget_SpatialAlgorithm_SPATIAL_ALGORITHM_AHRS: Phidget_SpatialAlgorithm = 1;
2913pub const Phidget_SpatialAlgorithm_SPATIAL_ALGORITHM_IMU: Phidget_SpatialAlgorithm = 2;
2914pub type Phidget_SpatialAlgorithm = ::std::os::raw::c_uint;
2915#[repr(C)]
2916#[derive(Debug, Copy, Clone)]
2917pub struct PhidgetSpatial_SpatialQuaternion {
2918 pub x: f64,
2919 pub y: f64,
2920 pub z: f64,
2921 pub w: f64,
2922}
2923#[test]
2924fn bindgen_test_layout_PhidgetSpatial_SpatialQuaternion() {
2925 const UNINIT: ::std::mem::MaybeUninit<PhidgetSpatial_SpatialQuaternion> =
2926 ::std::mem::MaybeUninit::uninit();
2927 let ptr = UNINIT.as_ptr();
2928 assert_eq!(
2929 ::std::mem::size_of::<PhidgetSpatial_SpatialQuaternion>(),
2930 32usize,
2931 "Size of PhidgetSpatial_SpatialQuaternion"
2932 );
2933 assert_eq!(
2934 ::std::mem::align_of::<PhidgetSpatial_SpatialQuaternion>(),
2935 8usize,
2936 "Alignment of PhidgetSpatial_SpatialQuaternion"
2937 );
2938 assert_eq!(
2939 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
2940 0usize,
2941 "Offset of field: PhidgetSpatial_SpatialQuaternion::x"
2942 );
2943 assert_eq!(
2944 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
2945 8usize,
2946 "Offset of field: PhidgetSpatial_SpatialQuaternion::y"
2947 );
2948 assert_eq!(
2949 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
2950 16usize,
2951 "Offset of field: PhidgetSpatial_SpatialQuaternion::z"
2952 );
2953 assert_eq!(
2954 unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
2955 24usize,
2956 "Offset of field: PhidgetSpatial_SpatialQuaternion::w"
2957 );
2958}
2959pub type PhidgetSpatial_SpatialQuaternionHandle = *mut PhidgetSpatial_SpatialQuaternion;
2960#[repr(C)]
2961#[derive(Debug, Copy, Clone)]
2962pub struct PhidgetSpatial_SpatialEulerAngles {
2963 pub pitch: f64,
2964 pub roll: f64,
2965 pub heading: f64,
2966}
2967#[test]
2968fn bindgen_test_layout_PhidgetSpatial_SpatialEulerAngles() {
2969 const UNINIT: ::std::mem::MaybeUninit<PhidgetSpatial_SpatialEulerAngles> =
2970 ::std::mem::MaybeUninit::uninit();
2971 let ptr = UNINIT.as_ptr();
2972 assert_eq!(
2973 ::std::mem::size_of::<PhidgetSpatial_SpatialEulerAngles>(),
2974 24usize,
2975 "Size of PhidgetSpatial_SpatialEulerAngles"
2976 );
2977 assert_eq!(
2978 ::std::mem::align_of::<PhidgetSpatial_SpatialEulerAngles>(),
2979 8usize,
2980 "Alignment of PhidgetSpatial_SpatialEulerAngles"
2981 );
2982 assert_eq!(
2983 unsafe { ::std::ptr::addr_of!((*ptr).pitch) as usize - ptr as usize },
2984 0usize,
2985 "Offset of field: PhidgetSpatial_SpatialEulerAngles::pitch"
2986 );
2987 assert_eq!(
2988 unsafe { ::std::ptr::addr_of!((*ptr).roll) as usize - ptr as usize },
2989 8usize,
2990 "Offset of field: PhidgetSpatial_SpatialEulerAngles::roll"
2991 );
2992 assert_eq!(
2993 unsafe { ::std::ptr::addr_of!((*ptr).heading) as usize - ptr as usize },
2994 16usize,
2995 "Offset of field: PhidgetSpatial_SpatialEulerAngles::heading"
2996 );
2997}
2998pub type PhidgetSpatial_SpatialEulerAnglesHandle = *mut PhidgetSpatial_SpatialEulerAngles;
2999pub const PhidgetTemperatureSensor_RTDType_RTD_TYPE_PT100_3850: PhidgetTemperatureSensor_RTDType =
3000 1;
3001pub const PhidgetTemperatureSensor_RTDType_RTD_TYPE_PT1000_3850: PhidgetTemperatureSensor_RTDType =
3002 2;
3003pub const PhidgetTemperatureSensor_RTDType_RTD_TYPE_PT100_3920: PhidgetTemperatureSensor_RTDType =
3004 3;
3005pub const PhidgetTemperatureSensor_RTDType_RTD_TYPE_PT1000_3920: PhidgetTemperatureSensor_RTDType =
3006 4;
3007pub type PhidgetTemperatureSensor_RTDType = ::std::os::raw::c_uint;
3008pub const PhidgetTemperatureSensor_ThermocoupleType_THERMOCOUPLE_TYPE_J:
3009 PhidgetTemperatureSensor_ThermocoupleType = 1;
3010pub const PhidgetTemperatureSensor_ThermocoupleType_THERMOCOUPLE_TYPE_K:
3011 PhidgetTemperatureSensor_ThermocoupleType = 2;
3012pub const PhidgetTemperatureSensor_ThermocoupleType_THERMOCOUPLE_TYPE_E:
3013 PhidgetTemperatureSensor_ThermocoupleType = 3;
3014pub const PhidgetTemperatureSensor_ThermocoupleType_THERMOCOUPLE_TYPE_T:
3015 PhidgetTemperatureSensor_ThermocoupleType = 4;
3016pub type PhidgetTemperatureSensor_ThermocoupleType = ::std::os::raw::c_uint;
3017pub const PhidgetFrequencyCounter_FilterType_FILTER_TYPE_ZERO_CROSSING:
3018 PhidgetFrequencyCounter_FilterType = 1;
3019pub const PhidgetFrequencyCounter_FilterType_FILTER_TYPE_LOGIC_LEVEL:
3020 PhidgetFrequencyCounter_FilterType = 2;
3021pub type PhidgetFrequencyCounter_FilterType = ::std::os::raw::c_uint;
3022pub const PhidgetIR_Encoding_IR_ENCODING_UNKNOWN: PhidgetIR_Encoding = 1;
3023pub const PhidgetIR_Encoding_IR_ENCODING_SPACE: PhidgetIR_Encoding = 2;
3024pub const PhidgetIR_Encoding_IR_ENCODING_PULSE: PhidgetIR_Encoding = 3;
3025pub const PhidgetIR_Encoding_IR_ENCODING_BIPHASE: PhidgetIR_Encoding = 4;
3026pub const PhidgetIR_Encoding_IR_ENCODING_RC5: PhidgetIR_Encoding = 5;
3027pub const PhidgetIR_Encoding_IR_ENCODING_RC6: PhidgetIR_Encoding = 6;
3028pub type PhidgetIR_Encoding = ::std::os::raw::c_uint;
3029pub const PhidgetIR_Length_IR_LENGTH_UNKNOWN: PhidgetIR_Length = 1;
3030pub const PhidgetIR_Length_IR_LENGTH_CONSTANT: PhidgetIR_Length = 2;
3031pub const PhidgetIR_Length_IR_LENGTH_VARIABLE: PhidgetIR_Length = 3;
3032pub type PhidgetIR_Length = ::std::os::raw::c_uint;
3033#[repr(C)]
3034#[derive(Debug, Copy, Clone)]
3035pub struct PhidgetIR_CodeInfo {
3036 pub bitCount: u32,
3037 pub encoding: PhidgetIR_Encoding,
3038 pub length: PhidgetIR_Length,
3039 pub gap: u32,
3040 pub trail: u32,
3041 pub header: [u32; 2usize],
3042 pub one: [u32; 2usize],
3043 pub zero: [u32; 2usize],
3044 pub repeat: [u32; 26usize],
3045 pub minRepeat: u32,
3046 pub dutyCycle: f64,
3047 pub carrierFrequency: u32,
3048 pub toggleMask: [::std::os::raw::c_char; 33usize],
3049}
3050#[test]
3051fn bindgen_test_layout_PhidgetIR_CodeInfo() {
3052 const UNINIT: ::std::mem::MaybeUninit<PhidgetIR_CodeInfo> = ::std::mem::MaybeUninit::uninit();
3053 let ptr = UNINIT.as_ptr();
3054 assert_eq!(
3055 ::std::mem::size_of::<PhidgetIR_CodeInfo>(),
3056 200usize,
3057 "Size of PhidgetIR_CodeInfo"
3058 );
3059 assert_eq!(
3060 ::std::mem::align_of::<PhidgetIR_CodeInfo>(),
3061 8usize,
3062 "Alignment of PhidgetIR_CodeInfo"
3063 );
3064 assert_eq!(
3065 unsafe { ::std::ptr::addr_of!((*ptr).bitCount) as usize - ptr as usize },
3066 0usize,
3067 "Offset of field: PhidgetIR_CodeInfo::bitCount"
3068 );
3069 assert_eq!(
3070 unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
3071 4usize,
3072 "Offset of field: PhidgetIR_CodeInfo::encoding"
3073 );
3074 assert_eq!(
3075 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
3076 8usize,
3077 "Offset of field: PhidgetIR_CodeInfo::length"
3078 );
3079 assert_eq!(
3080 unsafe { ::std::ptr::addr_of!((*ptr).gap) as usize - ptr as usize },
3081 12usize,
3082 "Offset of field: PhidgetIR_CodeInfo::gap"
3083 );
3084 assert_eq!(
3085 unsafe { ::std::ptr::addr_of!((*ptr).trail) as usize - ptr as usize },
3086 16usize,
3087 "Offset of field: PhidgetIR_CodeInfo::trail"
3088 );
3089 assert_eq!(
3090 unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
3091 20usize,
3092 "Offset of field: PhidgetIR_CodeInfo::header"
3093 );
3094 assert_eq!(
3095 unsafe { ::std::ptr::addr_of!((*ptr).one) as usize - ptr as usize },
3096 28usize,
3097 "Offset of field: PhidgetIR_CodeInfo::one"
3098 );
3099 assert_eq!(
3100 unsafe { ::std::ptr::addr_of!((*ptr).zero) as usize - ptr as usize },
3101 36usize,
3102 "Offset of field: PhidgetIR_CodeInfo::zero"
3103 );
3104 assert_eq!(
3105 unsafe { ::std::ptr::addr_of!((*ptr).repeat) as usize - ptr as usize },
3106 44usize,
3107 "Offset of field: PhidgetIR_CodeInfo::repeat"
3108 );
3109 assert_eq!(
3110 unsafe { ::std::ptr::addr_of!((*ptr).minRepeat) as usize - ptr as usize },
3111 148usize,
3112 "Offset of field: PhidgetIR_CodeInfo::minRepeat"
3113 );
3114 assert_eq!(
3115 unsafe { ::std::ptr::addr_of!((*ptr).dutyCycle) as usize - ptr as usize },
3116 152usize,
3117 "Offset of field: PhidgetIR_CodeInfo::dutyCycle"
3118 );
3119 assert_eq!(
3120 unsafe { ::std::ptr::addr_of!((*ptr).carrierFrequency) as usize - ptr as usize },
3121 160usize,
3122 "Offset of field: PhidgetIR_CodeInfo::carrierFrequency"
3123 );
3124 assert_eq!(
3125 unsafe { ::std::ptr::addr_of!((*ptr).toggleMask) as usize - ptr as usize },
3126 164usize,
3127 "Offset of field: PhidgetIR_CodeInfo::toggleMask"
3128 );
3129}
3130pub type PhidgetIR_CodeInfoHandle = *mut PhidgetIR_CodeInfo;
3131pub const PhidgetStepper_ControlMode_CONTROL_MODE_STEP: PhidgetStepper_ControlMode = 0;
3132pub const PhidgetStepper_ControlMode_CONTROL_MODE_RUN: PhidgetStepper_ControlMode = 1;
3133pub type PhidgetStepper_ControlMode = ::std::os::raw::c_uint;
3134pub const PhidgetLCD_Font_FONT_User1: PhidgetLCD_Font = 1;
3135pub const PhidgetLCD_Font_FONT_User2: PhidgetLCD_Font = 2;
3136pub const PhidgetLCD_Font_FONT_6x10: PhidgetLCD_Font = 3;
3137pub const PhidgetLCD_Font_FONT_5x8: PhidgetLCD_Font = 4;
3138pub const PhidgetLCD_Font_FONT_6x12: PhidgetLCD_Font = 5;
3139pub type PhidgetLCD_Font = ::std::os::raw::c_uint;
3140pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_NONE: PhidgetLCD_ScreenSize = 1;
3141pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_1x8: PhidgetLCD_ScreenSize = 2;
3142pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_2x8: PhidgetLCD_ScreenSize = 3;
3143pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_1x16: PhidgetLCD_ScreenSize = 4;
3144pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_2x16: PhidgetLCD_ScreenSize = 5;
3145pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_4x16: PhidgetLCD_ScreenSize = 6;
3146pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_2x20: PhidgetLCD_ScreenSize = 7;
3147pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_4x20: PhidgetLCD_ScreenSize = 8;
3148pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_2x24: PhidgetLCD_ScreenSize = 9;
3149pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_1x40: PhidgetLCD_ScreenSize = 10;
3150pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_2x40: PhidgetLCD_ScreenSize = 11;
3151pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_4x40: PhidgetLCD_ScreenSize = 12;
3152pub const PhidgetLCD_ScreenSize_SCREEN_SIZE_64x128: PhidgetLCD_ScreenSize = 13;
3153pub type PhidgetLCD_ScreenSize = ::std::os::raw::c_uint;
3154pub const PhidgetLCD_PixelState_PIXEL_STATE_OFF: PhidgetLCD_PixelState = 0;
3155pub const PhidgetLCD_PixelState_PIXEL_STATE_ON: PhidgetLCD_PixelState = 1;
3156pub const PhidgetLCD_PixelState_PIXEL_STATE_INVERT: PhidgetLCD_PixelState = 2;
3157pub type PhidgetLCD_PixelState = ::std::os::raw::c_uint;
3158pub const PhidgetDataAdapter_SPIMode_SPI_MODE_0: PhidgetDataAdapter_SPIMode = 1;
3159pub const PhidgetDataAdapter_SPIMode_SPI_MODE_1: PhidgetDataAdapter_SPIMode = 2;
3160pub const PhidgetDataAdapter_SPIMode_SPI_MODE_2: PhidgetDataAdapter_SPIMode = 3;
3161pub const PhidgetDataAdapter_SPIMode_SPI_MODE_3: PhidgetDataAdapter_SPIMode = 4;
3162pub type PhidgetDataAdapter_SPIMode = ::std::os::raw::c_uint;
3163pub const PhidgetDataAdapter_Frequency_FREQUENCY_10kHz: PhidgetDataAdapter_Frequency = 1;
3164pub const PhidgetDataAdapter_Frequency_FREQUENCY_100kHz: PhidgetDataAdapter_Frequency = 2;
3165pub const PhidgetDataAdapter_Frequency_FREQUENCY_400kHz: PhidgetDataAdapter_Frequency = 3;
3166pub const PhidgetDataAdapter_Frequency_FREQUENCY_188kHz: PhidgetDataAdapter_Frequency = 4;
3167pub const PhidgetDataAdapter_Frequency_FREQUENCY_375kHz: PhidgetDataAdapter_Frequency = 5;
3168pub const PhidgetDataAdapter_Frequency_FREQUENCY_750kHz: PhidgetDataAdapter_Frequency = 6;
3169pub const PhidgetDataAdapter_Frequency_FREQUENCY_1500kHz: PhidgetDataAdapter_Frequency = 7;
3170pub const PhidgetDataAdapter_Frequency_FREQUENCY_3MHz: PhidgetDataAdapter_Frequency = 8;
3171pub const PhidgetDataAdapter_Frequency_FREQUENCY_6MHz: PhidgetDataAdapter_Frequency = 9;
3172pub type PhidgetDataAdapter_Frequency = ::std::os::raw::c_uint;
3173pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_OK: PhidgetDataAdapter_PacketErrorCode =
3174 0;
3175pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_UNKNOWN:
3176 PhidgetDataAdapter_PacketErrorCode = 1;
3177pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_TIMEOUT:
3178 PhidgetDataAdapter_PacketErrorCode = 2;
3179pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_FORMAT:
3180 PhidgetDataAdapter_PacketErrorCode = 3;
3181pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_INVALID:
3182 PhidgetDataAdapter_PacketErrorCode = 4;
3183pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_OVERRUN:
3184 PhidgetDataAdapter_PacketErrorCode = 5;
3185pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_CORRUPT:
3186 PhidgetDataAdapter_PacketErrorCode = 6;
3187pub const PhidgetDataAdapter_PacketErrorCode_PACKET_ERROR_NACK: PhidgetDataAdapter_PacketErrorCode =
3188 7;
3189pub type PhidgetDataAdapter_PacketErrorCode = ::std::os::raw::c_uint;
3190pub const PhidgetDataAdapter_SPIChipSelect_SPI_CHIP_SELECT_ACTIVE_LOW:
3191 PhidgetDataAdapter_SPIChipSelect = 1;
3192pub const PhidgetDataAdapter_SPIChipSelect_SPI_CHIP_SELECT_ACTIVE_HIGH:
3193 PhidgetDataAdapter_SPIChipSelect = 2;
3194pub const PhidgetDataAdapter_SPIChipSelect_SPI_CHIP_SELECT_LOW: PhidgetDataAdapter_SPIChipSelect =
3195 3;
3196pub const PhidgetDataAdapter_SPIChipSelect_SPI_CHIP_SELECT_HIGH: PhidgetDataAdapter_SPIChipSelect =
3197 4;
3198pub type PhidgetDataAdapter_SPIChipSelect = ::std::os::raw::c_uint;
3199pub const PhidgetDataAdapter_Endianness_ENDIANNESS_MSB_FIRST: PhidgetDataAdapter_Endianness = 1;
3200pub const PhidgetDataAdapter_Endianness_ENDIANNESS_LSB_FIRST: PhidgetDataAdapter_Endianness = 2;
3201pub type PhidgetDataAdapter_Endianness = ::std::os::raw::c_uint;
3202#[repr(C)]
3203#[derive(Debug, Copy, Clone)]
3204pub struct PhidgetLEDArray_RGBW {
3205 pub r: u8,
3206 pub g: u8,
3207 pub b: u8,
3208 pub w: u8,
3209}
3210#[test]
3211fn bindgen_test_layout_PhidgetLEDArray_RGBW() {
3212 const UNINIT: ::std::mem::MaybeUninit<PhidgetLEDArray_RGBW> = ::std::mem::MaybeUninit::uninit();
3213 let ptr = UNINIT.as_ptr();
3214 assert_eq!(
3215 ::std::mem::size_of::<PhidgetLEDArray_RGBW>(),
3216 4usize,
3217 "Size of PhidgetLEDArray_RGBW"
3218 );
3219 assert_eq!(
3220 ::std::mem::align_of::<PhidgetLEDArray_RGBW>(),
3221 1usize,
3222 "Alignment of PhidgetLEDArray_RGBW"
3223 );
3224 assert_eq!(
3225 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
3226 0usize,
3227 "Offset of field: PhidgetLEDArray_RGBW::r"
3228 );
3229 assert_eq!(
3230 unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
3231 1usize,
3232 "Offset of field: PhidgetLEDArray_RGBW::g"
3233 );
3234 assert_eq!(
3235 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
3236 2usize,
3237 "Offset of field: PhidgetLEDArray_RGBW::b"
3238 );
3239 assert_eq!(
3240 unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
3241 3usize,
3242 "Offset of field: PhidgetLEDArray_RGBW::w"
3243 );
3244}
3245pub type PhidgetLEDArray_RGBWHandle = *mut PhidgetLEDArray_RGBW;
3246pub const PhidgetLEDArray_Protocol_LED_PROTOCOL_RGB: PhidgetLEDArray_Protocol = 1;
3247pub const PhidgetLEDArray_Protocol_LED_PROTOCOL_GRB: PhidgetLEDArray_Protocol = 2;
3248pub const PhidgetLEDArray_Protocol_LED_PROTOCOL_RGBW: PhidgetLEDArray_Protocol = 3;
3249pub const PhidgetLEDArray_Protocol_LED_PROTOCOL_GRBW: PhidgetLEDArray_Protocol = 4;
3250pub type PhidgetLEDArray_Protocol = ::std::os::raw::c_uint;
3251pub const PhidgetLEDArray_AnimationType_ANIMATION_TYPE_FORWARD_SCROLL:
3252 PhidgetLEDArray_AnimationType = 1;
3253pub const PhidgetLEDArray_AnimationType_ANIMATION_TYPE_REVERSE_SCROLL:
3254 PhidgetLEDArray_AnimationType = 2;
3255pub const PhidgetLEDArray_AnimationType_ANIMATION_TYPE_POPCORN: PhidgetLEDArray_AnimationType = 3;
3256pub const PhidgetLEDArray_AnimationType_ANIMATION_TYPE_FORWARD_SCROLL_MIRROR:
3257 PhidgetLEDArray_AnimationType = 4;
3258pub const PhidgetLEDArray_AnimationType_ANIMATION_TYPE_REVERSE_SCROLL_MIRROR:
3259 PhidgetLEDArray_AnimationType = 5;
3260pub type PhidgetLEDArray_AnimationType = ::std::os::raw::c_uint;
3261#[repr(C)]
3262#[derive(Debug, Copy, Clone)]
3263pub struct PhidgetLEDArray_AnimationDescription {
3264 pub startAddress: u16,
3265 pub span: u16,
3266 pub time: u16,
3267 pub animationType: PhidgetLEDArray_AnimationType,
3268}
3269#[test]
3270fn bindgen_test_layout_PhidgetLEDArray_AnimationDescription() {
3271 const UNINIT: ::std::mem::MaybeUninit<PhidgetLEDArray_AnimationDescription> =
3272 ::std::mem::MaybeUninit::uninit();
3273 let ptr = UNINIT.as_ptr();
3274 assert_eq!(
3275 ::std::mem::size_of::<PhidgetLEDArray_AnimationDescription>(),
3276 12usize,
3277 "Size of PhidgetLEDArray_AnimationDescription"
3278 );
3279 assert_eq!(
3280 ::std::mem::align_of::<PhidgetLEDArray_AnimationDescription>(),
3281 4usize,
3282 "Alignment of PhidgetLEDArray_AnimationDescription"
3283 );
3284 assert_eq!(
3285 unsafe { ::std::ptr::addr_of!((*ptr).startAddress) as usize - ptr as usize },
3286 0usize,
3287 "Offset of field: PhidgetLEDArray_AnimationDescription::startAddress"
3288 );
3289 assert_eq!(
3290 unsafe { ::std::ptr::addr_of!((*ptr).span) as usize - ptr as usize },
3291 2usize,
3292 "Offset of field: PhidgetLEDArray_AnimationDescription::span"
3293 );
3294 assert_eq!(
3295 unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
3296 4usize,
3297 "Offset of field: PhidgetLEDArray_AnimationDescription::time"
3298 );
3299 assert_eq!(
3300 unsafe { ::std::ptr::addr_of!((*ptr).animationType) as usize - ptr as usize },
3301 8usize,
3302 "Offset of field: PhidgetLEDArray_AnimationDescription::animationType"
3303 );
3304}
3305pub type PhidgetLEDArray_AnimationDescriptionHandle = *mut PhidgetLEDArray_AnimationDescription;
3306pub const PhidgetSoundSensor_SPLRange_SPL_RANGE_102dB: PhidgetSoundSensor_SPLRange = 1;
3307pub const PhidgetSoundSensor_SPLRange_SPL_RANGE_82dB: PhidgetSoundSensor_SPLRange = 2;
3308pub type PhidgetSoundSensor_SPLRange = ::std::os::raw::c_uint;
3309pub const PhidgetHub_PortMode_PORT_MODE_VINT_PORT: PhidgetHub_PortMode = 0;
3310pub const PhidgetHub_PortMode_PORT_MODE_DIGITAL_INPUT: PhidgetHub_PortMode = 1;
3311pub const PhidgetHub_PortMode_PORT_MODE_DIGITAL_OUTPUT: PhidgetHub_PortMode = 2;
3312pub const PhidgetHub_PortMode_PORT_MODE_VOLTAGE_INPUT: PhidgetHub_PortMode = 3;
3313pub const PhidgetHub_PortMode_PORT_MODE_VOLTAGE_RATIO_INPUT: PhidgetHub_PortMode = 4;
3314pub type PhidgetHub_PortMode = ::std::os::raw::c_uint;
3315#[repr(C)]
3316#[derive(Debug, Copy, Clone)]
3317pub struct _Phidget {
3318 _unused: [u8; 0],
3319}
3320pub type PhidgetHandle = *mut _Phidget;
3321extern "C" {
3322 pub fn Phidget_getErrorDescription(
3323 errorCode: PhidgetReturnCode,
3324 errorString: *mut *const ::std::os::raw::c_char,
3325 ) -> PhidgetReturnCode;
3326}
3327extern "C" {
3328 pub fn Phidget_finalize(flags: ::std::os::raw::c_int) -> PhidgetReturnCode;
3329}
3330extern "C" {
3331 pub fn Phidget_getLastError(
3332 errorCode: *mut PhidgetReturnCode,
3333 errorString: *mut *const ::std::os::raw::c_char,
3334 errorDetail: *mut ::std::os::raw::c_char,
3335 errorDetailLen: *mut usize,
3336 ) -> PhidgetReturnCode;
3337}
3338extern "C" {
3339 pub fn Phidget_release(phid: *mut PhidgetHandle) -> PhidgetReturnCode;
3340}
3341extern "C" {
3342 pub fn Phidget_resetLibrary() -> PhidgetReturnCode;
3343}
3344extern "C" {
3345 pub fn Phidget_retain(phid: PhidgetHandle) -> PhidgetReturnCode;
3346}
3347extern "C" {
3348 pub fn Phidget_getClientVersion(
3349 ch: PhidgetHandle,
3350 major: *mut ::std::os::raw::c_int,
3351 minor: *mut ::std::os::raw::c_int,
3352 ) -> PhidgetReturnCode;
3353}
3354extern "C" {
3355 pub fn Phidget_close(ch: PhidgetHandle) -> PhidgetReturnCode;
3356}
3357extern "C" {
3358 pub fn Phidget_getDeviceChannelCount(
3359 ch: PhidgetHandle,
3360 cls: Phidget_ChannelClass,
3361 count: *mut u32,
3362 ) -> PhidgetReturnCode;
3363}
3364extern "C" {
3365 pub fn Phidget_open(ch: PhidgetHandle) -> PhidgetReturnCode;
3366}
3367extern "C" {
3368 pub fn Phidget_openWaitForAttachment(ch: PhidgetHandle, timeout: u32) -> PhidgetReturnCode;
3369}
3370extern "C" {
3371 pub fn Phidget_reboot(ch: PhidgetHandle) -> PhidgetReturnCode;
3372}
3373extern "C" {
3374 pub fn Phidget_rebootFirmwareUpgrade(
3375 ch: PhidgetHandle,
3376 upgradeTimeout: u32,
3377 ) -> PhidgetReturnCode;
3378}
3379extern "C" {
3380 pub fn Phidget_getServerVersion(
3381 ch: PhidgetHandle,
3382 major: *mut ::std::os::raw::c_int,
3383 minor: *mut ::std::os::raw::c_int,
3384 ) -> PhidgetReturnCode;
3385}
3386extern "C" {
3387 pub fn Phidget_writeDeviceLabel(
3388 ch: PhidgetHandle,
3389 deviceLabel: *const ::std::os::raw::c_char,
3390 ) -> PhidgetReturnCode;
3391}
3392extern "C" {
3393 pub fn Phidget_writeFlash(ch: PhidgetHandle) -> PhidgetReturnCode;
3394}
3395extern "C" {
3396 pub fn Phidget_getLibraryVersion(
3397 libraryVersion: *mut *const ::std::os::raw::c_char,
3398 ) -> PhidgetReturnCode;
3399}
3400extern "C" {
3401 pub fn Phidget_getLibraryVersionNumber(
3402 libraryVersionNumber: *mut *const ::std::os::raw::c_char,
3403 ) -> PhidgetReturnCode;
3404}
3405extern "C" {
3406 pub fn Phidget_getAttached(
3407 ch: PhidgetHandle,
3408 attached: *mut ::std::os::raw::c_int,
3409 ) -> PhidgetReturnCode;
3410}
3411extern "C" {
3412 pub fn Phidget_setChannel(
3413 ch: PhidgetHandle,
3414 channel: ::std::os::raw::c_int,
3415 ) -> PhidgetReturnCode;
3416}
3417extern "C" {
3418 pub fn Phidget_getChannel(
3419 ch: PhidgetHandle,
3420 channel: *mut ::std::os::raw::c_int,
3421 ) -> PhidgetReturnCode;
3422}
3423extern "C" {
3424 pub fn Phidget_getIsChannel(
3425 ch: PhidgetHandle,
3426 isChannel: *mut ::std::os::raw::c_int,
3427 ) -> PhidgetReturnCode;
3428}
3429extern "C" {
3430 pub fn Phidget_getChannelClass(
3431 ch: PhidgetHandle,
3432 channelClass: *mut Phidget_ChannelClass,
3433 ) -> PhidgetReturnCode;
3434}
3435extern "C" {
3436 pub fn Phidget_getChannelClassName(
3437 ch: PhidgetHandle,
3438 channelClassName: *mut *const ::std::os::raw::c_char,
3439 ) -> PhidgetReturnCode;
3440}
3441extern "C" {
3442 pub fn Phidget_getChannelName(
3443 ch: PhidgetHandle,
3444 channelName: *mut *const ::std::os::raw::c_char,
3445 ) -> PhidgetReturnCode;
3446}
3447extern "C" {
3448 pub fn Phidget_getChannelSubclass(
3449 ch: PhidgetHandle,
3450 channelSubclass: *mut Phidget_ChannelSubclass,
3451 ) -> PhidgetReturnCode;
3452}
3453extern "C" {
3454 pub fn Phidget_setDataInterval(ch: PhidgetHandle, dataInterval: u32) -> PhidgetReturnCode;
3455}
3456extern "C" {
3457 pub fn Phidget_getDataInterval(ch: PhidgetHandle, dataInterval: *mut u32) -> PhidgetReturnCode;
3458}
3459extern "C" {
3460 pub fn Phidget_getMinDataInterval(
3461 ch: PhidgetHandle,
3462 minDataInterval: *mut u32,
3463 ) -> PhidgetReturnCode;
3464}
3465extern "C" {
3466 pub fn Phidget_getMaxDataInterval(
3467 ch: PhidgetHandle,
3468 maxDataInterval: *mut u32,
3469 ) -> PhidgetReturnCode;
3470}
3471extern "C" {
3472 pub fn Phidget_setDataRate(ch: PhidgetHandle, dataRate: f64) -> PhidgetReturnCode;
3473}
3474extern "C" {
3475 pub fn Phidget_getDataRate(ch: PhidgetHandle, dataRate: *mut f64) -> PhidgetReturnCode;
3476}
3477extern "C" {
3478 pub fn Phidget_getMinDataRate(ch: PhidgetHandle, minDataRate: *mut f64) -> PhidgetReturnCode;
3479}
3480extern "C" {
3481 pub fn Phidget_getMaxDataRate(ch: PhidgetHandle, maxDataRate: *mut f64) -> PhidgetReturnCode;
3482}
3483extern "C" {
3484 pub fn Phidget_getDeviceClass(
3485 ch: PhidgetHandle,
3486 deviceClass: *mut Phidget_DeviceClass,
3487 ) -> PhidgetReturnCode;
3488}
3489extern "C" {
3490 pub fn Phidget_getDeviceClassName(
3491 ch: PhidgetHandle,
3492 deviceClassName: *mut *const ::std::os::raw::c_char,
3493 ) -> PhidgetReturnCode;
3494}
3495extern "C" {
3496 pub fn Phidget_getDeviceFirmwareUpgradeString(
3497 ch: PhidgetHandle,
3498 deviceFirmwareUpgradeString: *mut *const ::std::os::raw::c_char,
3499 ) -> PhidgetReturnCode;
3500}
3501extern "C" {
3502 pub fn Phidget_getDeviceID(
3503 ch: PhidgetHandle,
3504 deviceID: *mut Phidget_DeviceID,
3505 ) -> PhidgetReturnCode;
3506}
3507extern "C" {
3508 pub fn Phidget_setDeviceLabel(
3509 ch: PhidgetHandle,
3510 deviceLabel: *const ::std::os::raw::c_char,
3511 ) -> PhidgetReturnCode;
3512}
3513extern "C" {
3514 pub fn Phidget_getDeviceLabel(
3515 ch: PhidgetHandle,
3516 deviceLabel: *mut *const ::std::os::raw::c_char,
3517 ) -> PhidgetReturnCode;
3518}
3519extern "C" {
3520 pub fn Phidget_getDeviceName(
3521 ch: PhidgetHandle,
3522 deviceName: *mut *const ::std::os::raw::c_char,
3523 ) -> PhidgetReturnCode;
3524}
3525extern "C" {
3526 pub fn Phidget_setDeviceSerialNumber(
3527 ch: PhidgetHandle,
3528 deviceSerialNumber: i32,
3529 ) -> PhidgetReturnCode;
3530}
3531extern "C" {
3532 pub fn Phidget_getDeviceSerialNumber(
3533 ch: PhidgetHandle,
3534 deviceSerialNumber: *mut i32,
3535 ) -> PhidgetReturnCode;
3536}
3537extern "C" {
3538 pub fn Phidget_getDeviceSKU(
3539 ch: PhidgetHandle,
3540 deviceSKU: *mut *const ::std::os::raw::c_char,
3541 ) -> PhidgetReturnCode;
3542}
3543extern "C" {
3544 pub fn Phidget_getDeviceVersion(
3545 ch: PhidgetHandle,
3546 deviceVersion: *mut ::std::os::raw::c_int,
3547 ) -> PhidgetReturnCode;
3548}
3549extern "C" {
3550 pub fn Phidget_getDeviceVINTID(ch: PhidgetHandle, deviceVINTID: *mut u32) -> PhidgetReturnCode;
3551}
3552extern "C" {
3553 pub fn Phidget_getHub(ch: PhidgetHandle, hub: *mut PhidgetHandle) -> PhidgetReturnCode;
3554}
3555extern "C" {
3556 pub fn Phidget_setHubPort(
3557 ch: PhidgetHandle,
3558 hubPort: ::std::os::raw::c_int,
3559 ) -> PhidgetReturnCode;
3560}
3561extern "C" {
3562 pub fn Phidget_getHubPort(
3563 ch: PhidgetHandle,
3564 hubPort: *mut ::std::os::raw::c_int,
3565 ) -> PhidgetReturnCode;
3566}
3567extern "C" {
3568 pub fn Phidget_getHubPortCount(
3569 ch: PhidgetHandle,
3570 hubPortCount: *mut ::std::os::raw::c_int,
3571 ) -> PhidgetReturnCode;
3572}
3573extern "C" {
3574 pub fn Phidget_setIsHubPortDevice(
3575 ch: PhidgetHandle,
3576 isHubPortDevice: ::std::os::raw::c_int,
3577 ) -> PhidgetReturnCode;
3578}
3579extern "C" {
3580 pub fn Phidget_getIsHubPortDevice(
3581 ch: PhidgetHandle,
3582 isHubPortDevice: *mut ::std::os::raw::c_int,
3583 ) -> PhidgetReturnCode;
3584}
3585extern "C" {
3586 pub fn Phidget_setHubPortSpeed(ch: PhidgetHandle, hubPortSpeed: u32) -> PhidgetReturnCode;
3587}
3588extern "C" {
3589 pub fn Phidget_getHubPortSpeed(ch: PhidgetHandle, hubPortSpeed: *mut u32) -> PhidgetReturnCode;
3590}
3591extern "C" {
3592 pub fn Phidget_getMaxHubPortSpeed(
3593 ch: PhidgetHandle,
3594 maxHubPortSpeed: *mut u32,
3595 ) -> PhidgetReturnCode;
3596}
3597extern "C" {
3598 pub fn Phidget_getHubPortSupportsAutoSetSpeed(
3599 ch: PhidgetHandle,
3600 hubPortSupportsAutoSetSpeed: *mut ::std::os::raw::c_int,
3601 ) -> PhidgetReturnCode;
3602}
3603extern "C" {
3604 pub fn Phidget_getHubPortSupportsSetSpeed(
3605 ch: PhidgetHandle,
3606 hubPortSupportsSetSpeed: *mut ::std::os::raw::c_int,
3607 ) -> PhidgetReturnCode;
3608}
3609extern "C" {
3610 pub fn Phidget_setIsLocal(
3611 ch: PhidgetHandle,
3612 isLocal: ::std::os::raw::c_int,
3613 ) -> PhidgetReturnCode;
3614}
3615extern "C" {
3616 pub fn Phidget_getIsLocal(
3617 ch: PhidgetHandle,
3618 isLocal: *mut ::std::os::raw::c_int,
3619 ) -> PhidgetReturnCode;
3620}
3621extern "C" {
3622 pub fn Phidget_setMeshMode(ch: PhidgetHandle, meshMode: Phidget_MeshMode) -> PhidgetReturnCode;
3623}
3624extern "C" {
3625 pub fn Phidget_getMeshMode(
3626 ch: PhidgetHandle,
3627 meshMode: *mut Phidget_MeshMode,
3628 ) -> PhidgetReturnCode;
3629}
3630extern "C" {
3631 pub fn Phidget_getIsOpen(
3632 ch: PhidgetHandle,
3633 isOpen: *mut ::std::os::raw::c_int,
3634 ) -> PhidgetReturnCode;
3635}
3636extern "C" {
3637 pub fn Phidget_getParent(ch: PhidgetHandle, parent: *mut PhidgetHandle) -> PhidgetReturnCode;
3638}
3639extern "C" {
3640 pub fn Phidget_setIsRemote(
3641 ch: PhidgetHandle,
3642 isRemote: ::std::os::raw::c_int,
3643 ) -> PhidgetReturnCode;
3644}
3645extern "C" {
3646 pub fn Phidget_getIsRemote(
3647 ch: PhidgetHandle,
3648 isRemote: *mut ::std::os::raw::c_int,
3649 ) -> PhidgetReturnCode;
3650}
3651extern "C" {
3652 pub fn Phidget_getServerHostname(
3653 ch: PhidgetHandle,
3654 serverHostname: *mut *const ::std::os::raw::c_char,
3655 ) -> PhidgetReturnCode;
3656}
3657extern "C" {
3658 pub fn Phidget_setServerName(
3659 ch: PhidgetHandle,
3660 serverName: *const ::std::os::raw::c_char,
3661 ) -> PhidgetReturnCode;
3662}
3663extern "C" {
3664 pub fn Phidget_getServerName(
3665 ch: PhidgetHandle,
3666 serverName: *mut *const ::std::os::raw::c_char,
3667 ) -> PhidgetReturnCode;
3668}
3669extern "C" {
3670 pub fn Phidget_getServerPeerName(
3671 ch: PhidgetHandle,
3672 serverPeerName: *mut *const ::std::os::raw::c_char,
3673 ) -> PhidgetReturnCode;
3674}
3675extern "C" {
3676 pub fn Phidget_getServerUniqueName(
3677 ch: PhidgetHandle,
3678 serverUniqueName: *mut *const ::std::os::raw::c_char,
3679 ) -> PhidgetReturnCode;
3680}
3681extern "C" {
3682 pub fn Phidget_getMaxVINTDeviceSpeed(
3683 ch: PhidgetHandle,
3684 maxVINTDeviceSpeed: *mut u32,
3685 ) -> PhidgetReturnCode;
3686}
3687extern "C" {
3688 pub fn Phidget_getVINTDeviceSupportsAutoSetSpeed(
3689 ch: PhidgetHandle,
3690 VINTDeviceSupportsAutoSetSpeed: *mut ::std::os::raw::c_int,
3691 ) -> PhidgetReturnCode;
3692}
3693extern "C" {
3694 pub fn Phidget_getVINTDeviceSupportsSetSpeed(
3695 ch: PhidgetHandle,
3696 VINTDeviceSupportsSetSpeed: *mut ::std::os::raw::c_int,
3697 ) -> PhidgetReturnCode;
3698}
3699pub type Phidget_OnAttachCallback = ::std::option::Option<
3700 unsafe extern "C" fn(ch: PhidgetHandle, ctx: *mut ::std::os::raw::c_void),
3701>;
3702extern "C" {
3703 pub fn Phidget_setOnAttachHandler(
3704 ch: PhidgetHandle,
3705 fptr: Phidget_OnAttachCallback,
3706 ctx: *mut ::std::os::raw::c_void,
3707 ) -> PhidgetReturnCode;
3708}
3709pub type Phidget_OnDetachCallback = ::std::option::Option<
3710 unsafe extern "C" fn(ch: PhidgetHandle, ctx: *mut ::std::os::raw::c_void),
3711>;
3712extern "C" {
3713 pub fn Phidget_setOnDetachHandler(
3714 ch: PhidgetHandle,
3715 fptr: Phidget_OnDetachCallback,
3716 ctx: *mut ::std::os::raw::c_void,
3717 ) -> PhidgetReturnCode;
3718}
3719pub type Phidget_OnErrorCallback = ::std::option::Option<
3720 unsafe extern "C" fn(
3721 ch: PhidgetHandle,
3722 ctx: *mut ::std::os::raw::c_void,
3723 code: Phidget_ErrorEventCode,
3724 description: *const ::std::os::raw::c_char,
3725 ),
3726>;
3727extern "C" {
3728 pub fn Phidget_setOnErrorHandler(
3729 ch: PhidgetHandle,
3730 fptr: Phidget_OnErrorCallback,
3731 ctx: *mut ::std::os::raw::c_void,
3732 ) -> PhidgetReturnCode;
3733}
3734pub type Phidget_OnPropertyChangeCallback = ::std::option::Option<
3735 unsafe extern "C" fn(
3736 ch: PhidgetHandle,
3737 ctx: *mut ::std::os::raw::c_void,
3738 propertyName: *const ::std::os::raw::c_char,
3739 ),
3740>;
3741extern "C" {
3742 pub fn Phidget_setOnPropertyChangeHandler(
3743 ch: PhidgetHandle,
3744 fptr: Phidget_OnPropertyChangeCallback,
3745 ctx: *mut ::std::os::raw::c_void,
3746 ) -> PhidgetReturnCode;
3747}
3748pub type Phidget_AsyncCallback = ::std::option::Option<
3749 unsafe extern "C" fn(
3750 phid: PhidgetHandle,
3751 ctx: *mut ::std::os::raw::c_void,
3752 returnCode: PhidgetReturnCode,
3753 ),
3754>;
3755extern "C" {
3756 pub fn Phidget_delete(phid: *mut PhidgetHandle) -> PhidgetReturnCode;
3757}
3758extern "C" {
3759 pub fn Phidget_getChildDevices(
3760 phid: PhidgetHandle,
3761 arr: *mut PhidgetHandle,
3762 arrCnt: *mut usize,
3763 ) -> PhidgetReturnCode;
3764}
3765extern "C" {
3766 pub fn Phidget_releaseDevices(arr: *mut PhidgetHandle, arrCnt: usize) -> PhidgetReturnCode;
3767}
3768extern "C" {
3769 pub fn Phidget_validDictionaryKey(arg1: *const ::std::os::raw::c_char)
3770 -> ::std::os::raw::c_int;
3771}
3772pub type PhidgetDictionary_OnChangeCallback = ::std::option::Option<
3773 unsafe extern "C" fn(
3774 arg1: ::std::os::raw::c_int,
3775 arg2: *const ::std::os::raw::c_char,
3776 arg3: *mut ::std::os::raw::c_void,
3777 arg4: ::std::os::raw::c_int,
3778 arg5: *const ::std::os::raw::c_char,
3779 arg6: *const ::std::os::raw::c_char,
3780 ),
3781>;
3782extern "C" {
3783 pub fn PhidgetDictionary_setOnChangeCallbackHandler(
3784 arg1: PhidgetDictionary_OnChangeCallback,
3785 arg2: *mut ::std::os::raw::c_void,
3786 ) -> PhidgetReturnCode;
3787}
3788#[repr(C)]
3789#[derive(Debug, Copy, Clone)]
3790pub struct _PhidgetManager {
3791 _unused: [u8; 0],
3792}
3793pub type PhidgetManagerHandle = *mut _PhidgetManager;
3794extern "C" {
3795 pub fn PhidgetManager_create(man: *mut PhidgetManagerHandle) -> PhidgetReturnCode;
3796}
3797extern "C" {
3798 pub fn PhidgetManager_delete(man: *mut PhidgetManagerHandle) -> PhidgetReturnCode;
3799}
3800extern "C" {
3801 pub fn PhidgetManager_close(man: PhidgetManagerHandle) -> PhidgetReturnCode;
3802}
3803extern "C" {
3804 pub fn PhidgetManager_open(man: PhidgetManagerHandle) -> PhidgetReturnCode;
3805}
3806pub type PhidgetManager_OnAttachCallback = ::std::option::Option<
3807 unsafe extern "C" fn(
3808 man: PhidgetManagerHandle,
3809 ctx: *mut ::std::os::raw::c_void,
3810 channel: PhidgetHandle,
3811 ),
3812>;
3813extern "C" {
3814 pub fn PhidgetManager_setOnAttachHandler(
3815 man: PhidgetManagerHandle,
3816 fptr: PhidgetManager_OnAttachCallback,
3817 ctx: *mut ::std::os::raw::c_void,
3818 ) -> PhidgetReturnCode;
3819}
3820pub type PhidgetManager_OnDetachCallback = ::std::option::Option<
3821 unsafe extern "C" fn(
3822 man: PhidgetManagerHandle,
3823 ctx: *mut ::std::os::raw::c_void,
3824 channel: PhidgetHandle,
3825 ),
3826>;
3827extern "C" {
3828 pub fn PhidgetManager_setOnDetachHandler(
3829 man: PhidgetManagerHandle,
3830 fptr: PhidgetManager_OnDetachCallback,
3831 ctx: *mut ::std::os::raw::c_void,
3832 ) -> PhidgetReturnCode;
3833}
3834extern "C" {
3835 pub fn PhidgetLog_disable() -> PhidgetReturnCode;
3836}
3837extern "C" {
3838 pub fn PhidgetLog_enable(
3839 level: Phidget_LogLevel,
3840 destination: *const ::std::os::raw::c_char,
3841 ) -> PhidgetReturnCode;
3842}
3843extern "C" {
3844 pub fn PhidgetLog_getLevel(level: *mut Phidget_LogLevel) -> PhidgetReturnCode;
3845}
3846extern "C" {
3847 pub fn PhidgetLog_setLevel(level: Phidget_LogLevel) -> PhidgetReturnCode;
3848}
3849extern "C" {
3850 pub fn PhidgetLog_log(
3851 level: Phidget_LogLevel,
3852 message: *const ::std::os::raw::c_char,
3853 ...
3854 ) -> PhidgetReturnCode;
3855}
3856extern "C" {
3857 pub fn PhidgetLog_loge(
3858 file: *const ::std::os::raw::c_char,
3859 line: ::std::os::raw::c_int,
3860 function: *const ::std::os::raw::c_char,
3861 source: *const ::std::os::raw::c_char,
3862 level: Phidget_LogLevel,
3863 message: *const ::std::os::raw::c_char,
3864 ...
3865 ) -> PhidgetReturnCode;
3866}
3867extern "C" {
3868 pub fn PhidgetLog_loges(
3869 level: Phidget_LogLevel,
3870 source: *const ::std::os::raw::c_char,
3871 message: *const ::std::os::raw::c_char,
3872 ) -> PhidgetReturnCode;
3873}
3874extern "C" {
3875 pub fn PhidgetLog_logs(
3876 level: Phidget_LogLevel,
3877 message: *const ::std::os::raw::c_char,
3878 ) -> PhidgetReturnCode;
3879}
3880extern "C" {
3881 pub fn PhidgetLog_rotate() -> PhidgetReturnCode;
3882}
3883extern "C" {
3884 pub fn PhidgetLog_isRotating(isrotating: *mut ::std::os::raw::c_int) -> PhidgetReturnCode;
3885}
3886extern "C" {
3887 pub fn PhidgetLog_getRotating(
3888 size: *mut u64,
3889 keepCount: *mut ::std::os::raw::c_int,
3890 ) -> PhidgetReturnCode;
3891}
3892extern "C" {
3893 pub fn PhidgetLog_setRotating(size: u64, keepCount: ::std::os::raw::c_int)
3894 -> PhidgetReturnCode;
3895}
3896extern "C" {
3897 pub fn PhidgetLog_enableRotating() -> PhidgetReturnCode;
3898}
3899extern "C" {
3900 pub fn PhidgetLog_disableRotating() -> PhidgetReturnCode;
3901}
3902extern "C" {
3903 pub fn PhidgetLog_addSource(
3904 source: *const ::std::os::raw::c_char,
3905 level: Phidget_LogLevel,
3906 ) -> PhidgetReturnCode;
3907}
3908extern "C" {
3909 pub fn PhidgetLog_getSourceLevel(
3910 source: *const ::std::os::raw::c_char,
3911 level: *mut Phidget_LogLevel,
3912 ) -> PhidgetReturnCode;
3913}
3914extern "C" {
3915 pub fn PhidgetLog_setSourceLevel(
3916 source: *const ::std::os::raw::c_char,
3917 level: Phidget_LogLevel,
3918 ) -> PhidgetReturnCode;
3919}
3920extern "C" {
3921 pub fn PhidgetLog_getSources(
3922 sources: *mut *const ::std::os::raw::c_char,
3923 count: *mut u32,
3924 ) -> PhidgetReturnCode;
3925}
3926extern "C" {
3927 pub fn PhidgetLog_enableNetwork(
3928 address: *const ::std::os::raw::c_char,
3929 port: ::std::os::raw::c_int,
3930 ) -> PhidgetReturnCode;
3931}
3932extern "C" {
3933 pub fn PhidgetLog_disableNetwork() -> PhidgetReturnCode;
3934}
3935extern "C" {
3936 pub fn PhidgetNet_removeAllServers() -> PhidgetReturnCode;
3937}
3938extern "C" {
3939 pub fn PhidgetNet_freeServerAddressList(
3940 addressList: *mut *const ::std::os::raw::c_char,
3941 count: u32,
3942 ) -> PhidgetReturnCode;
3943}
3944extern "C" {
3945 pub fn PhidgetNet_setProperty(
3946 key: *const ::std::os::raw::c_char,
3947 property: *const ::std::os::raw::c_char,
3948 ...
3949 ) -> PhidgetReturnCode;
3950}
3951extern "C" {
3952 pub fn PhidgetNet_addServer(
3953 serverName: *const ::std::os::raw::c_char,
3954 address: *const ::std::os::raw::c_char,
3955 port: ::std::os::raw::c_int,
3956 password: *const ::std::os::raw::c_char,
3957 flags: ::std::os::raw::c_int,
3958 ) -> PhidgetReturnCode;
3959}
3960extern "C" {
3961 pub fn PhidgetNet_removeServer(serverName: *const ::std::os::raw::c_char) -> PhidgetReturnCode;
3962}
3963extern "C" {
3964 pub fn PhidgetNet_enableServer(serverName: *const ::std::os::raw::c_char) -> PhidgetReturnCode;
3965}
3966extern "C" {
3967 pub fn PhidgetNet_disableServer(
3968 serverName: *const ::std::os::raw::c_char,
3969 flags: ::std::os::raw::c_int,
3970 ) -> PhidgetReturnCode;
3971}
3972extern "C" {
3973 pub fn PhidgetNet_getServerAddressList(
3974 hostname: *const ::std::os::raw::c_char,
3975 addressFamily: ::std::os::raw::c_int,
3976 addressList: *mut *const ::std::os::raw::c_char,
3977 count: *mut u32,
3978 ) -> PhidgetReturnCode;
3979}
3980extern "C" {
3981 pub fn PhidgetNet_enableServerDiscovery(serverType: PhidgetServerType) -> PhidgetReturnCode;
3982}
3983extern "C" {
3984 pub fn PhidgetNet_disableServerDiscovery(serverType: PhidgetServerType) -> PhidgetReturnCode;
3985}
3986extern "C" {
3987 pub fn PhidgetNet_setServerPassword(
3988 serverName: *const ::std::os::raw::c_char,
3989 password: *const ::std::os::raw::c_char,
3990 ) -> PhidgetReturnCode;
3991}
3992extern "C" {
3993 pub fn PhidgetNet_startServer(
3994 flags: ::std::os::raw::c_int,
3995 addressFamily: ::std::os::raw::c_int,
3996 serverName: *const ::std::os::raw::c_char,
3997 address: *const ::std::os::raw::c_char,
3998 port: ::std::os::raw::c_int,
3999 password: *const ::std::os::raw::c_char,
4000 server: *mut *mut PhidgetServer,
4001 ) -> PhidgetReturnCode;
4002}
4003extern "C" {
4004 pub fn PhidgetNet_stopServer(server: *mut *mut PhidgetServer) -> PhidgetReturnCode;
4005}
4006pub type PhidgetNet_OnServerAddedCallback = ::std::option::Option<
4007 unsafe extern "C" fn(
4008 ctx: *mut ::std::os::raw::c_void,
4009 server: *mut PhidgetServer,
4010 kv: *mut ::std::os::raw::c_void,
4011 ),
4012>;
4013extern "C" {
4014 pub fn PhidgetNet_setOnServerAddedHandler(
4015 fptr: PhidgetNet_OnServerAddedCallback,
4016 ctx: *mut ::std::os::raw::c_void,
4017 ) -> PhidgetReturnCode;
4018}
4019pub type PhidgetNet_OnServerRemovedCallback = ::std::option::Option<
4020 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, server: *mut PhidgetServer),
4021>;
4022extern "C" {
4023 pub fn PhidgetNet_setOnServerRemovedHandler(
4024 fptr: PhidgetNet_OnServerRemovedCallback,
4025 ctx: *mut ::std::os::raw::c_void,
4026 ) -> PhidgetReturnCode;
4027}
4028extern "C" {
4029 pub fn Phidget_enumString(
4030 arg1: *const ::std::os::raw::c_char,
4031 arg2: ::std::os::raw::c_int,
4032 ) -> *const ::std::os::raw::c_char;
4033}
4034extern "C" {
4035 pub fn Phidget_enumFromString(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4036}
4037#[repr(C)]
4038#[derive(Debug, Copy, Clone)]
4039pub struct _PhidgetAccelerometer {
4040 _unused: [u8; 0],
4041}
4042pub type PhidgetAccelerometerHandle = *mut _PhidgetAccelerometer;
4043extern "C" {
4044 pub fn PhidgetAccelerometer_create(ch: *mut PhidgetAccelerometerHandle) -> PhidgetReturnCode;
4045}
4046extern "C" {
4047 pub fn PhidgetAccelerometer_delete(ch: *mut PhidgetAccelerometerHandle) -> PhidgetReturnCode;
4048}
4049extern "C" {
4050 pub fn PhidgetAccelerometer_getAcceleration(
4051 ch: PhidgetAccelerometerHandle,
4052 acceleration: *mut [f64; 3usize],
4053 ) -> PhidgetReturnCode;
4054}
4055extern "C" {
4056 pub fn PhidgetAccelerometer_getMinAcceleration(
4057 ch: PhidgetAccelerometerHandle,
4058 minAcceleration: *mut [f64; 3usize],
4059 ) -> PhidgetReturnCode;
4060}
4061extern "C" {
4062 pub fn PhidgetAccelerometer_getMaxAcceleration(
4063 ch: PhidgetAccelerometerHandle,
4064 maxAcceleration: *mut [f64; 3usize],
4065 ) -> PhidgetReturnCode;
4066}
4067extern "C" {
4068 pub fn PhidgetAccelerometer_setAccelerationChangeTrigger(
4069 ch: PhidgetAccelerometerHandle,
4070 accelerationChangeTrigger: f64,
4071 ) -> PhidgetReturnCode;
4072}
4073extern "C" {
4074 pub fn PhidgetAccelerometer_getAccelerationChangeTrigger(
4075 ch: PhidgetAccelerometerHandle,
4076 accelerationChangeTrigger: *mut f64,
4077 ) -> PhidgetReturnCode;
4078}
4079extern "C" {
4080 pub fn PhidgetAccelerometer_getMinAccelerationChangeTrigger(
4081 ch: PhidgetAccelerometerHandle,
4082 minAccelerationChangeTrigger: *mut f64,
4083 ) -> PhidgetReturnCode;
4084}
4085extern "C" {
4086 pub fn PhidgetAccelerometer_getMaxAccelerationChangeTrigger(
4087 ch: PhidgetAccelerometerHandle,
4088 maxAccelerationChangeTrigger: *mut f64,
4089 ) -> PhidgetReturnCode;
4090}
4091extern "C" {
4092 pub fn PhidgetAccelerometer_getAxisCount(
4093 ch: PhidgetAccelerometerHandle,
4094 axisCount: *mut ::std::os::raw::c_int,
4095 ) -> PhidgetReturnCode;
4096}
4097extern "C" {
4098 pub fn PhidgetAccelerometer_setDataInterval(
4099 ch: PhidgetAccelerometerHandle,
4100 dataInterval: u32,
4101 ) -> PhidgetReturnCode;
4102}
4103extern "C" {
4104 pub fn PhidgetAccelerometer_getDataInterval(
4105 ch: PhidgetAccelerometerHandle,
4106 dataInterval: *mut u32,
4107 ) -> PhidgetReturnCode;
4108}
4109extern "C" {
4110 pub fn PhidgetAccelerometer_getMinDataInterval(
4111 ch: PhidgetAccelerometerHandle,
4112 minDataInterval: *mut u32,
4113 ) -> PhidgetReturnCode;
4114}
4115extern "C" {
4116 pub fn PhidgetAccelerometer_getMaxDataInterval(
4117 ch: PhidgetAccelerometerHandle,
4118 maxDataInterval: *mut u32,
4119 ) -> PhidgetReturnCode;
4120}
4121extern "C" {
4122 pub fn PhidgetAccelerometer_setDataRate(
4123 ch: PhidgetAccelerometerHandle,
4124 dataRate: f64,
4125 ) -> PhidgetReturnCode;
4126}
4127extern "C" {
4128 pub fn PhidgetAccelerometer_getDataRate(
4129 ch: PhidgetAccelerometerHandle,
4130 dataRate: *mut f64,
4131 ) -> PhidgetReturnCode;
4132}
4133extern "C" {
4134 pub fn PhidgetAccelerometer_getMinDataRate(
4135 ch: PhidgetAccelerometerHandle,
4136 minDataRate: *mut f64,
4137 ) -> PhidgetReturnCode;
4138}
4139extern "C" {
4140 pub fn PhidgetAccelerometer_getMaxDataRate(
4141 ch: PhidgetAccelerometerHandle,
4142 maxDataRate: *mut f64,
4143 ) -> PhidgetReturnCode;
4144}
4145extern "C" {
4146 pub fn PhidgetAccelerometer_setHeatingEnabled(
4147 ch: PhidgetAccelerometerHandle,
4148 heatingEnabled: ::std::os::raw::c_int,
4149 ) -> PhidgetReturnCode;
4150}
4151extern "C" {
4152 pub fn PhidgetAccelerometer_getHeatingEnabled(
4153 ch: PhidgetAccelerometerHandle,
4154 heatingEnabled: *mut ::std::os::raw::c_int,
4155 ) -> PhidgetReturnCode;
4156}
4157extern "C" {
4158 pub fn PhidgetAccelerometer_setPrecision(
4159 ch: PhidgetAccelerometerHandle,
4160 precision: Phidget_SpatialPrecision,
4161 ) -> PhidgetReturnCode;
4162}
4163extern "C" {
4164 pub fn PhidgetAccelerometer_getPrecision(
4165 ch: PhidgetAccelerometerHandle,
4166 precision: *mut Phidget_SpatialPrecision,
4167 ) -> PhidgetReturnCode;
4168}
4169extern "C" {
4170 pub fn PhidgetAccelerometer_getTimestamp(
4171 ch: PhidgetAccelerometerHandle,
4172 timestamp: *mut f64,
4173 ) -> PhidgetReturnCode;
4174}
4175pub type PhidgetAccelerometer_OnAccelerationChangeCallback = ::std::option::Option<
4176 unsafe extern "C" fn(
4177 ch: PhidgetAccelerometerHandle,
4178 ctx: *mut ::std::os::raw::c_void,
4179 acceleration: *const f64,
4180 timestamp: f64,
4181 ),
4182>;
4183extern "C" {
4184 pub fn PhidgetAccelerometer_setOnAccelerationChangeHandler(
4185 ch: PhidgetAccelerometerHandle,
4186 fptr: PhidgetAccelerometer_OnAccelerationChangeCallback,
4187 ctx: *mut ::std::os::raw::c_void,
4188 ) -> PhidgetReturnCode;
4189}
4190#[repr(C)]
4191#[derive(Debug, Copy, Clone)]
4192pub struct _PhidgetBLDCMotor {
4193 _unused: [u8; 0],
4194}
4195pub type PhidgetBLDCMotorHandle = *mut _PhidgetBLDCMotor;
4196extern "C" {
4197 pub fn PhidgetBLDCMotor_create(ch: *mut PhidgetBLDCMotorHandle) -> PhidgetReturnCode;
4198}
4199extern "C" {
4200 pub fn PhidgetBLDCMotor_delete(ch: *mut PhidgetBLDCMotorHandle) -> PhidgetReturnCode;
4201}
4202extern "C" {
4203 pub fn PhidgetBLDCMotor_enableFailsafe(
4204 ch: PhidgetBLDCMotorHandle,
4205 failsafeTime: u32,
4206 ) -> PhidgetReturnCode;
4207}
4208extern "C" {
4209 pub fn PhidgetBLDCMotor_addPositionOffset(
4210 ch: PhidgetBLDCMotorHandle,
4211 positionOffset: f64,
4212 ) -> PhidgetReturnCode;
4213}
4214extern "C" {
4215 pub fn PhidgetBLDCMotor_resetFailsafe(ch: PhidgetBLDCMotorHandle) -> PhidgetReturnCode;
4216}
4217extern "C" {
4218 pub fn PhidgetBLDCMotor_setAcceleration(
4219 ch: PhidgetBLDCMotorHandle,
4220 acceleration: f64,
4221 ) -> PhidgetReturnCode;
4222}
4223extern "C" {
4224 pub fn PhidgetBLDCMotor_getAcceleration(
4225 ch: PhidgetBLDCMotorHandle,
4226 acceleration: *mut f64,
4227 ) -> PhidgetReturnCode;
4228}
4229extern "C" {
4230 pub fn PhidgetBLDCMotor_getMinAcceleration(
4231 ch: PhidgetBLDCMotorHandle,
4232 minAcceleration: *mut f64,
4233 ) -> PhidgetReturnCode;
4234}
4235extern "C" {
4236 pub fn PhidgetBLDCMotor_getMaxAcceleration(
4237 ch: PhidgetBLDCMotorHandle,
4238 maxAcceleration: *mut f64,
4239 ) -> PhidgetReturnCode;
4240}
4241extern "C" {
4242 pub fn PhidgetBLDCMotor_getActiveCurrentLimit(
4243 ch: PhidgetBLDCMotorHandle,
4244 activeCurrentLimit: *mut f64,
4245 ) -> PhidgetReturnCode;
4246}
4247extern "C" {
4248 pub fn PhidgetBLDCMotor_setBrakingEnabled(
4249 ch: PhidgetBLDCMotorHandle,
4250 brakingEnabled: ::std::os::raw::c_int,
4251 ) -> PhidgetReturnCode;
4252}
4253extern "C" {
4254 pub fn PhidgetBLDCMotor_getBrakingEnabled(
4255 ch: PhidgetBLDCMotorHandle,
4256 brakingEnabled: *mut ::std::os::raw::c_int,
4257 ) -> PhidgetReturnCode;
4258}
4259extern "C" {
4260 pub fn PhidgetBLDCMotor_getBrakingStrength(
4261 ch: PhidgetBLDCMotorHandle,
4262 brakingStrength: *mut f64,
4263 ) -> PhidgetReturnCode;
4264}
4265extern "C" {
4266 pub fn PhidgetBLDCMotor_getMinBrakingStrength(
4267 ch: PhidgetBLDCMotorHandle,
4268 minBrakingStrength: *mut f64,
4269 ) -> PhidgetReturnCode;
4270}
4271extern "C" {
4272 pub fn PhidgetBLDCMotor_getMaxBrakingStrength(
4273 ch: PhidgetBLDCMotorHandle,
4274 maxBrakingStrength: *mut f64,
4275 ) -> PhidgetReturnCode;
4276}
4277extern "C" {
4278 pub fn PhidgetBLDCMotor_setCurrentLimit(
4279 ch: PhidgetBLDCMotorHandle,
4280 currentLimit: f64,
4281 ) -> PhidgetReturnCode;
4282}
4283extern "C" {
4284 pub fn PhidgetBLDCMotor_getCurrentLimit(
4285 ch: PhidgetBLDCMotorHandle,
4286 currentLimit: *mut f64,
4287 ) -> PhidgetReturnCode;
4288}
4289extern "C" {
4290 pub fn PhidgetBLDCMotor_getMinCurrentLimit(
4291 ch: PhidgetBLDCMotorHandle,
4292 minCurrentLimit: *mut f64,
4293 ) -> PhidgetReturnCode;
4294}
4295extern "C" {
4296 pub fn PhidgetBLDCMotor_getMaxCurrentLimit(
4297 ch: PhidgetBLDCMotorHandle,
4298 maxCurrentLimit: *mut f64,
4299 ) -> PhidgetReturnCode;
4300}
4301extern "C" {
4302 pub fn PhidgetBLDCMotor_setDataInterval(
4303 ch: PhidgetBLDCMotorHandle,
4304 dataInterval: u32,
4305 ) -> PhidgetReturnCode;
4306}
4307extern "C" {
4308 pub fn PhidgetBLDCMotor_getDataInterval(
4309 ch: PhidgetBLDCMotorHandle,
4310 dataInterval: *mut u32,
4311 ) -> PhidgetReturnCode;
4312}
4313extern "C" {
4314 pub fn PhidgetBLDCMotor_getMinDataInterval(
4315 ch: PhidgetBLDCMotorHandle,
4316 minDataInterval: *mut u32,
4317 ) -> PhidgetReturnCode;
4318}
4319extern "C" {
4320 pub fn PhidgetBLDCMotor_getMaxDataInterval(
4321 ch: PhidgetBLDCMotorHandle,
4322 maxDataInterval: *mut u32,
4323 ) -> PhidgetReturnCode;
4324}
4325extern "C" {
4326 pub fn PhidgetBLDCMotor_setDataRate(
4327 ch: PhidgetBLDCMotorHandle,
4328 dataRate: f64,
4329 ) -> PhidgetReturnCode;
4330}
4331extern "C" {
4332 pub fn PhidgetBLDCMotor_getDataRate(
4333 ch: PhidgetBLDCMotorHandle,
4334 dataRate: *mut f64,
4335 ) -> PhidgetReturnCode;
4336}
4337extern "C" {
4338 pub fn PhidgetBLDCMotor_getMinDataRate(
4339 ch: PhidgetBLDCMotorHandle,
4340 minDataRate: *mut f64,
4341 ) -> PhidgetReturnCode;
4342}
4343extern "C" {
4344 pub fn PhidgetBLDCMotor_getMaxDataRate(
4345 ch: PhidgetBLDCMotorHandle,
4346 maxDataRate: *mut f64,
4347 ) -> PhidgetReturnCode;
4348}
4349extern "C" {
4350 pub fn PhidgetBLDCMotor_setDriveMode(
4351 ch: PhidgetBLDCMotorHandle,
4352 driveMode: Phidget_DriveMode,
4353 ) -> PhidgetReturnCode;
4354}
4355extern "C" {
4356 pub fn PhidgetBLDCMotor_getDriveMode(
4357 ch: PhidgetBLDCMotorHandle,
4358 driveMode: *mut Phidget_DriveMode,
4359 ) -> PhidgetReturnCode;
4360}
4361extern "C" {
4362 pub fn PhidgetBLDCMotor_setFailsafeBrakingEnabled(
4363 ch: PhidgetBLDCMotorHandle,
4364 failsafeBrakingEnabled: ::std::os::raw::c_int,
4365 ) -> PhidgetReturnCode;
4366}
4367extern "C" {
4368 pub fn PhidgetBLDCMotor_getFailsafeBrakingEnabled(
4369 ch: PhidgetBLDCMotorHandle,
4370 failsafeBrakingEnabled: *mut ::std::os::raw::c_int,
4371 ) -> PhidgetReturnCode;
4372}
4373extern "C" {
4374 pub fn PhidgetBLDCMotor_setFailsafeCurrentLimit(
4375 ch: PhidgetBLDCMotorHandle,
4376 failsafeCurrentLimit: f64,
4377 ) -> PhidgetReturnCode;
4378}
4379extern "C" {
4380 pub fn PhidgetBLDCMotor_getFailsafeCurrentLimit(
4381 ch: PhidgetBLDCMotorHandle,
4382 failsafeCurrentLimit: *mut f64,
4383 ) -> PhidgetReturnCode;
4384}
4385extern "C" {
4386 pub fn PhidgetBLDCMotor_getMinFailsafeTime(
4387 ch: PhidgetBLDCMotorHandle,
4388 minFailsafeTime: *mut u32,
4389 ) -> PhidgetReturnCode;
4390}
4391extern "C" {
4392 pub fn PhidgetBLDCMotor_getMaxFailsafeTime(
4393 ch: PhidgetBLDCMotorHandle,
4394 maxFailsafeTime: *mut u32,
4395 ) -> PhidgetReturnCode;
4396}
4397extern "C" {
4398 pub fn PhidgetBLDCMotor_setInductance(
4399 ch: PhidgetBLDCMotorHandle,
4400 inductance: f64,
4401 ) -> PhidgetReturnCode;
4402}
4403extern "C" {
4404 pub fn PhidgetBLDCMotor_getInductance(
4405 ch: PhidgetBLDCMotorHandle,
4406 inductance: *mut f64,
4407 ) -> PhidgetReturnCode;
4408}
4409extern "C" {
4410 pub fn PhidgetBLDCMotor_getMinInductance(
4411 ch: PhidgetBLDCMotorHandle,
4412 minInductance: *mut f64,
4413 ) -> PhidgetReturnCode;
4414}
4415extern "C" {
4416 pub fn PhidgetBLDCMotor_getMaxInductance(
4417 ch: PhidgetBLDCMotorHandle,
4418 maxInductance: *mut f64,
4419 ) -> PhidgetReturnCode;
4420}
4421extern "C" {
4422 pub fn PhidgetBLDCMotor_getPosition(
4423 ch: PhidgetBLDCMotorHandle,
4424 position: *mut f64,
4425 ) -> PhidgetReturnCode;
4426}
4427extern "C" {
4428 pub fn PhidgetBLDCMotor_getMinPosition(
4429 ch: PhidgetBLDCMotorHandle,
4430 minPosition: *mut f64,
4431 ) -> PhidgetReturnCode;
4432}
4433extern "C" {
4434 pub fn PhidgetBLDCMotor_getMaxPosition(
4435 ch: PhidgetBLDCMotorHandle,
4436 maxPosition: *mut f64,
4437 ) -> PhidgetReturnCode;
4438}
4439extern "C" {
4440 pub fn PhidgetBLDCMotor_setRescaleFactor(
4441 ch: PhidgetBLDCMotorHandle,
4442 rescaleFactor: f64,
4443 ) -> PhidgetReturnCode;
4444}
4445extern "C" {
4446 pub fn PhidgetBLDCMotor_getRescaleFactor(
4447 ch: PhidgetBLDCMotorHandle,
4448 rescaleFactor: *mut f64,
4449 ) -> PhidgetReturnCode;
4450}
4451extern "C" {
4452 pub fn PhidgetBLDCMotor_setStallVelocity(
4453 ch: PhidgetBLDCMotorHandle,
4454 stallVelocity: f64,
4455 ) -> PhidgetReturnCode;
4456}
4457extern "C" {
4458 pub fn PhidgetBLDCMotor_getStallVelocity(
4459 ch: PhidgetBLDCMotorHandle,
4460 stallVelocity: *mut f64,
4461 ) -> PhidgetReturnCode;
4462}
4463extern "C" {
4464 pub fn PhidgetBLDCMotor_getMinStallVelocity(
4465 ch: PhidgetBLDCMotorHandle,
4466 minStallVelocity: *mut f64,
4467 ) -> PhidgetReturnCode;
4468}
4469extern "C" {
4470 pub fn PhidgetBLDCMotor_getMaxStallVelocity(
4471 ch: PhidgetBLDCMotorHandle,
4472 maxStallVelocity: *mut f64,
4473 ) -> PhidgetReturnCode;
4474}
4475extern "C" {
4476 pub fn PhidgetBLDCMotor_setSurgeCurrentLimit(
4477 ch: PhidgetBLDCMotorHandle,
4478 surgeCurrentLimit: f64,
4479 ) -> PhidgetReturnCode;
4480}
4481extern "C" {
4482 pub fn PhidgetBLDCMotor_getSurgeCurrentLimit(
4483 ch: PhidgetBLDCMotorHandle,
4484 surgeCurrentLimit: *mut f64,
4485 ) -> PhidgetReturnCode;
4486}
4487extern "C" {
4488 pub fn PhidgetBLDCMotor_getMinSurgeCurrentLimit(
4489 ch: PhidgetBLDCMotorHandle,
4490 minSurgeCurrentLimit: *mut f64,
4491 ) -> PhidgetReturnCode;
4492}
4493extern "C" {
4494 pub fn PhidgetBLDCMotor_getMaxSurgeCurrentLimit(
4495 ch: PhidgetBLDCMotorHandle,
4496 maxSurgeCurrentLimit: *mut f64,
4497 ) -> PhidgetReturnCode;
4498}
4499extern "C" {
4500 pub fn PhidgetBLDCMotor_setTargetBrakingStrength(
4501 ch: PhidgetBLDCMotorHandle,
4502 targetBrakingStrength: f64,
4503 ) -> PhidgetReturnCode;
4504}
4505extern "C" {
4506 pub fn PhidgetBLDCMotor_getTargetBrakingStrength(
4507 ch: PhidgetBLDCMotorHandle,
4508 targetBrakingStrength: *mut f64,
4509 ) -> PhidgetReturnCode;
4510}
4511extern "C" {
4512 pub fn PhidgetBLDCMotor_setTargetVelocity(
4513 ch: PhidgetBLDCMotorHandle,
4514 targetVelocity: f64,
4515 ) -> PhidgetReturnCode;
4516}
4517extern "C" {
4518 pub fn PhidgetBLDCMotor_setTargetVelocity_async(
4519 ch: PhidgetBLDCMotorHandle,
4520 targetVelocity: f64,
4521 fptr: Phidget_AsyncCallback,
4522 ctx: *mut ::std::os::raw::c_void,
4523 );
4524}
4525extern "C" {
4526 pub fn PhidgetBLDCMotor_getTargetVelocity(
4527 ch: PhidgetBLDCMotorHandle,
4528 targetVelocity: *mut f64,
4529 ) -> PhidgetReturnCode;
4530}
4531extern "C" {
4532 pub fn PhidgetBLDCMotor_getVelocity(
4533 ch: PhidgetBLDCMotorHandle,
4534 velocity: *mut f64,
4535 ) -> PhidgetReturnCode;
4536}
4537extern "C" {
4538 pub fn PhidgetBLDCMotor_getMinVelocity(
4539 ch: PhidgetBLDCMotorHandle,
4540 minVelocity: *mut f64,
4541 ) -> PhidgetReturnCode;
4542}
4543extern "C" {
4544 pub fn PhidgetBLDCMotor_getMaxVelocity(
4545 ch: PhidgetBLDCMotorHandle,
4546 maxVelocity: *mut f64,
4547 ) -> PhidgetReturnCode;
4548}
4549pub type PhidgetBLDCMotor_OnBrakingStrengthChangeCallback = ::std::option::Option<
4550 unsafe extern "C" fn(
4551 ch: PhidgetBLDCMotorHandle,
4552 ctx: *mut ::std::os::raw::c_void,
4553 brakingStrength: f64,
4554 ),
4555>;
4556extern "C" {
4557 pub fn PhidgetBLDCMotor_setOnBrakingStrengthChangeHandler(
4558 ch: PhidgetBLDCMotorHandle,
4559 fptr: PhidgetBLDCMotor_OnBrakingStrengthChangeCallback,
4560 ctx: *mut ::std::os::raw::c_void,
4561 ) -> PhidgetReturnCode;
4562}
4563pub type PhidgetBLDCMotor_OnPositionChangeCallback = ::std::option::Option<
4564 unsafe extern "C" fn(
4565 ch: PhidgetBLDCMotorHandle,
4566 ctx: *mut ::std::os::raw::c_void,
4567 position: f64,
4568 ),
4569>;
4570extern "C" {
4571 pub fn PhidgetBLDCMotor_setOnPositionChangeHandler(
4572 ch: PhidgetBLDCMotorHandle,
4573 fptr: PhidgetBLDCMotor_OnPositionChangeCallback,
4574 ctx: *mut ::std::os::raw::c_void,
4575 ) -> PhidgetReturnCode;
4576}
4577pub type PhidgetBLDCMotor_OnVelocityUpdateCallback = ::std::option::Option<
4578 unsafe extern "C" fn(
4579 ch: PhidgetBLDCMotorHandle,
4580 ctx: *mut ::std::os::raw::c_void,
4581 velocity: f64,
4582 ),
4583>;
4584extern "C" {
4585 pub fn PhidgetBLDCMotor_setOnVelocityUpdateHandler(
4586 ch: PhidgetBLDCMotorHandle,
4587 fptr: PhidgetBLDCMotor_OnVelocityUpdateCallback,
4588 ctx: *mut ::std::os::raw::c_void,
4589 ) -> PhidgetReturnCode;
4590}
4591#[repr(C)]
4592#[derive(Debug, Copy, Clone)]
4593pub struct _PhidgetCapacitiveTouch {
4594 _unused: [u8; 0],
4595}
4596pub type PhidgetCapacitiveTouchHandle = *mut _PhidgetCapacitiveTouch;
4597extern "C" {
4598 pub fn PhidgetCapacitiveTouch_create(
4599 ch: *mut PhidgetCapacitiveTouchHandle,
4600 ) -> PhidgetReturnCode;
4601}
4602extern "C" {
4603 pub fn PhidgetCapacitiveTouch_delete(
4604 ch: *mut PhidgetCapacitiveTouchHandle,
4605 ) -> PhidgetReturnCode;
4606}
4607extern "C" {
4608 pub fn PhidgetCapacitiveTouch_setDataInterval(
4609 ch: PhidgetCapacitiveTouchHandle,
4610 dataInterval: u32,
4611 ) -> PhidgetReturnCode;
4612}
4613extern "C" {
4614 pub fn PhidgetCapacitiveTouch_getDataInterval(
4615 ch: PhidgetCapacitiveTouchHandle,
4616 dataInterval: *mut u32,
4617 ) -> PhidgetReturnCode;
4618}
4619extern "C" {
4620 pub fn PhidgetCapacitiveTouch_getMinDataInterval(
4621 ch: PhidgetCapacitiveTouchHandle,
4622 minDataInterval: *mut u32,
4623 ) -> PhidgetReturnCode;
4624}
4625extern "C" {
4626 pub fn PhidgetCapacitiveTouch_getMaxDataInterval(
4627 ch: PhidgetCapacitiveTouchHandle,
4628 maxDataInterval: *mut u32,
4629 ) -> PhidgetReturnCode;
4630}
4631extern "C" {
4632 pub fn PhidgetCapacitiveTouch_setDataRate(
4633 ch: PhidgetCapacitiveTouchHandle,
4634 dataRate: f64,
4635 ) -> PhidgetReturnCode;
4636}
4637extern "C" {
4638 pub fn PhidgetCapacitiveTouch_getDataRate(
4639 ch: PhidgetCapacitiveTouchHandle,
4640 dataRate: *mut f64,
4641 ) -> PhidgetReturnCode;
4642}
4643extern "C" {
4644 pub fn PhidgetCapacitiveTouch_getMinDataRate(
4645 ch: PhidgetCapacitiveTouchHandle,
4646 minDataRate: *mut f64,
4647 ) -> PhidgetReturnCode;
4648}
4649extern "C" {
4650 pub fn PhidgetCapacitiveTouch_getMaxDataRate(
4651 ch: PhidgetCapacitiveTouchHandle,
4652 maxDataRate: *mut f64,
4653 ) -> PhidgetReturnCode;
4654}
4655extern "C" {
4656 pub fn PhidgetCapacitiveTouch_setSensitivity(
4657 ch: PhidgetCapacitiveTouchHandle,
4658 sensitivity: f64,
4659 ) -> PhidgetReturnCode;
4660}
4661extern "C" {
4662 pub fn PhidgetCapacitiveTouch_getSensitivity(
4663 ch: PhidgetCapacitiveTouchHandle,
4664 sensitivity: *mut f64,
4665 ) -> PhidgetReturnCode;
4666}
4667extern "C" {
4668 pub fn PhidgetCapacitiveTouch_getMinSensitivity(
4669 ch: PhidgetCapacitiveTouchHandle,
4670 minSensitivity: *mut f64,
4671 ) -> PhidgetReturnCode;
4672}
4673extern "C" {
4674 pub fn PhidgetCapacitiveTouch_getMaxSensitivity(
4675 ch: PhidgetCapacitiveTouchHandle,
4676 maxSensitivity: *mut f64,
4677 ) -> PhidgetReturnCode;
4678}
4679extern "C" {
4680 pub fn PhidgetCapacitiveTouch_getIsTouched(
4681 ch: PhidgetCapacitiveTouchHandle,
4682 isTouched: *mut ::std::os::raw::c_int,
4683 ) -> PhidgetReturnCode;
4684}
4685extern "C" {
4686 pub fn PhidgetCapacitiveTouch_getTouchValue(
4687 ch: PhidgetCapacitiveTouchHandle,
4688 touchValue: *mut f64,
4689 ) -> PhidgetReturnCode;
4690}
4691extern "C" {
4692 pub fn PhidgetCapacitiveTouch_getMinTouchValue(
4693 ch: PhidgetCapacitiveTouchHandle,
4694 minTouchValue: *mut f64,
4695 ) -> PhidgetReturnCode;
4696}
4697extern "C" {
4698 pub fn PhidgetCapacitiveTouch_getMaxTouchValue(
4699 ch: PhidgetCapacitiveTouchHandle,
4700 maxTouchValue: *mut f64,
4701 ) -> PhidgetReturnCode;
4702}
4703extern "C" {
4704 pub fn PhidgetCapacitiveTouch_setTouchValueChangeTrigger(
4705 ch: PhidgetCapacitiveTouchHandle,
4706 touchValueChangeTrigger: f64,
4707 ) -> PhidgetReturnCode;
4708}
4709extern "C" {
4710 pub fn PhidgetCapacitiveTouch_getTouchValueChangeTrigger(
4711 ch: PhidgetCapacitiveTouchHandle,
4712 touchValueChangeTrigger: *mut f64,
4713 ) -> PhidgetReturnCode;
4714}
4715extern "C" {
4716 pub fn PhidgetCapacitiveTouch_getMinTouchValueChangeTrigger(
4717 ch: PhidgetCapacitiveTouchHandle,
4718 minTouchValueChangeTrigger: *mut f64,
4719 ) -> PhidgetReturnCode;
4720}
4721extern "C" {
4722 pub fn PhidgetCapacitiveTouch_getMaxTouchValueChangeTrigger(
4723 ch: PhidgetCapacitiveTouchHandle,
4724 maxTouchValueChangeTrigger: *mut f64,
4725 ) -> PhidgetReturnCode;
4726}
4727pub type PhidgetCapacitiveTouch_OnTouchCallback = ::std::option::Option<
4728 unsafe extern "C" fn(
4729 ch: PhidgetCapacitiveTouchHandle,
4730 ctx: *mut ::std::os::raw::c_void,
4731 touchValue: f64,
4732 ),
4733>;
4734extern "C" {
4735 pub fn PhidgetCapacitiveTouch_setOnTouchHandler(
4736 ch: PhidgetCapacitiveTouchHandle,
4737 fptr: PhidgetCapacitiveTouch_OnTouchCallback,
4738 ctx: *mut ::std::os::raw::c_void,
4739 ) -> PhidgetReturnCode;
4740}
4741pub type PhidgetCapacitiveTouch_OnTouchEndCallback = ::std::option::Option<
4742 unsafe extern "C" fn(ch: PhidgetCapacitiveTouchHandle, ctx: *mut ::std::os::raw::c_void),
4743>;
4744extern "C" {
4745 pub fn PhidgetCapacitiveTouch_setOnTouchEndHandler(
4746 ch: PhidgetCapacitiveTouchHandle,
4747 fptr: PhidgetCapacitiveTouch_OnTouchEndCallback,
4748 ctx: *mut ::std::os::raw::c_void,
4749 ) -> PhidgetReturnCode;
4750}
4751#[repr(C)]
4752#[derive(Debug, Copy, Clone)]
4753pub struct _PhidgetCurrentInput {
4754 _unused: [u8; 0],
4755}
4756pub type PhidgetCurrentInputHandle = *mut _PhidgetCurrentInput;
4757extern "C" {
4758 pub fn PhidgetCurrentInput_create(ch: *mut PhidgetCurrentInputHandle) -> PhidgetReturnCode;
4759}
4760extern "C" {
4761 pub fn PhidgetCurrentInput_delete(ch: *mut PhidgetCurrentInputHandle) -> PhidgetReturnCode;
4762}
4763extern "C" {
4764 pub fn PhidgetCurrentInput_getCurrent(
4765 ch: PhidgetCurrentInputHandle,
4766 current: *mut f64,
4767 ) -> PhidgetReturnCode;
4768}
4769extern "C" {
4770 pub fn PhidgetCurrentInput_getMinCurrent(
4771 ch: PhidgetCurrentInputHandle,
4772 minCurrent: *mut f64,
4773 ) -> PhidgetReturnCode;
4774}
4775extern "C" {
4776 pub fn PhidgetCurrentInput_getMaxCurrent(
4777 ch: PhidgetCurrentInputHandle,
4778 maxCurrent: *mut f64,
4779 ) -> PhidgetReturnCode;
4780}
4781extern "C" {
4782 pub fn PhidgetCurrentInput_setCurrentChangeTrigger(
4783 ch: PhidgetCurrentInputHandle,
4784 currentChangeTrigger: f64,
4785 ) -> PhidgetReturnCode;
4786}
4787extern "C" {
4788 pub fn PhidgetCurrentInput_getCurrentChangeTrigger(
4789 ch: PhidgetCurrentInputHandle,
4790 currentChangeTrigger: *mut f64,
4791 ) -> PhidgetReturnCode;
4792}
4793extern "C" {
4794 pub fn PhidgetCurrentInput_getMinCurrentChangeTrigger(
4795 ch: PhidgetCurrentInputHandle,
4796 minCurrentChangeTrigger: *mut f64,
4797 ) -> PhidgetReturnCode;
4798}
4799extern "C" {
4800 pub fn PhidgetCurrentInput_getMaxCurrentChangeTrigger(
4801 ch: PhidgetCurrentInputHandle,
4802 maxCurrentChangeTrigger: *mut f64,
4803 ) -> PhidgetReturnCode;
4804}
4805extern "C" {
4806 pub fn PhidgetCurrentInput_setDataInterval(
4807 ch: PhidgetCurrentInputHandle,
4808 dataInterval: u32,
4809 ) -> PhidgetReturnCode;
4810}
4811extern "C" {
4812 pub fn PhidgetCurrentInput_getDataInterval(
4813 ch: PhidgetCurrentInputHandle,
4814 dataInterval: *mut u32,
4815 ) -> PhidgetReturnCode;
4816}
4817extern "C" {
4818 pub fn PhidgetCurrentInput_getMinDataInterval(
4819 ch: PhidgetCurrentInputHandle,
4820 minDataInterval: *mut u32,
4821 ) -> PhidgetReturnCode;
4822}
4823extern "C" {
4824 pub fn PhidgetCurrentInput_getMaxDataInterval(
4825 ch: PhidgetCurrentInputHandle,
4826 maxDataInterval: *mut u32,
4827 ) -> PhidgetReturnCode;
4828}
4829extern "C" {
4830 pub fn PhidgetCurrentInput_setDataRate(
4831 ch: PhidgetCurrentInputHandle,
4832 dataRate: f64,
4833 ) -> PhidgetReturnCode;
4834}
4835extern "C" {
4836 pub fn PhidgetCurrentInput_getDataRate(
4837 ch: PhidgetCurrentInputHandle,
4838 dataRate: *mut f64,
4839 ) -> PhidgetReturnCode;
4840}
4841extern "C" {
4842 pub fn PhidgetCurrentInput_getMinDataRate(
4843 ch: PhidgetCurrentInputHandle,
4844 minDataRate: *mut f64,
4845 ) -> PhidgetReturnCode;
4846}
4847extern "C" {
4848 pub fn PhidgetCurrentInput_getMaxDataRate(
4849 ch: PhidgetCurrentInputHandle,
4850 maxDataRate: *mut f64,
4851 ) -> PhidgetReturnCode;
4852}
4853extern "C" {
4854 pub fn PhidgetCurrentInput_setPowerSupply(
4855 ch: PhidgetCurrentInputHandle,
4856 powerSupply: Phidget_PowerSupply,
4857 ) -> PhidgetReturnCode;
4858}
4859extern "C" {
4860 pub fn PhidgetCurrentInput_getPowerSupply(
4861 ch: PhidgetCurrentInputHandle,
4862 powerSupply: *mut Phidget_PowerSupply,
4863 ) -> PhidgetReturnCode;
4864}
4865pub type PhidgetCurrentInput_OnCurrentChangeCallback = ::std::option::Option<
4866 unsafe extern "C" fn(
4867 ch: PhidgetCurrentInputHandle,
4868 ctx: *mut ::std::os::raw::c_void,
4869 current: f64,
4870 ),
4871>;
4872extern "C" {
4873 pub fn PhidgetCurrentInput_setOnCurrentChangeHandler(
4874 ch: PhidgetCurrentInputHandle,
4875 fptr: PhidgetCurrentInput_OnCurrentChangeCallback,
4876 ctx: *mut ::std::os::raw::c_void,
4877 ) -> PhidgetReturnCode;
4878}
4879#[repr(C)]
4880#[derive(Debug, Copy, Clone)]
4881pub struct _PhidgetCurrentOutput {
4882 _unused: [u8; 0],
4883}
4884pub type PhidgetCurrentOutputHandle = *mut _PhidgetCurrentOutput;
4885extern "C" {
4886 pub fn PhidgetCurrentOutput_create(ch: *mut PhidgetCurrentOutputHandle) -> PhidgetReturnCode;
4887}
4888extern "C" {
4889 pub fn PhidgetCurrentOutput_delete(ch: *mut PhidgetCurrentOutputHandle) -> PhidgetReturnCode;
4890}
4891extern "C" {
4892 pub fn PhidgetCurrentOutput_setCurrent(
4893 ch: PhidgetCurrentOutputHandle,
4894 current: f64,
4895 ) -> PhidgetReturnCode;
4896}
4897extern "C" {
4898 pub fn PhidgetCurrentOutput_setCurrent_async(
4899 ch: PhidgetCurrentOutputHandle,
4900 current: f64,
4901 fptr: Phidget_AsyncCallback,
4902 ctx: *mut ::std::os::raw::c_void,
4903 );
4904}
4905extern "C" {
4906 pub fn PhidgetCurrentOutput_getCurrent(
4907 ch: PhidgetCurrentOutputHandle,
4908 current: *mut f64,
4909 ) -> PhidgetReturnCode;
4910}
4911extern "C" {
4912 pub fn PhidgetCurrentOutput_getMinCurrent(
4913 ch: PhidgetCurrentOutputHandle,
4914 minCurrent: *mut f64,
4915 ) -> PhidgetReturnCode;
4916}
4917extern "C" {
4918 pub fn PhidgetCurrentOutput_getMaxCurrent(
4919 ch: PhidgetCurrentOutputHandle,
4920 maxCurrent: *mut f64,
4921 ) -> PhidgetReturnCode;
4922}
4923extern "C" {
4924 pub fn PhidgetCurrentOutput_setEnabled(
4925 ch: PhidgetCurrentOutputHandle,
4926 enabled: ::std::os::raw::c_int,
4927 ) -> PhidgetReturnCode;
4928}
4929extern "C" {
4930 pub fn PhidgetCurrentOutput_getEnabled(
4931 ch: PhidgetCurrentOutputHandle,
4932 enabled: *mut ::std::os::raw::c_int,
4933 ) -> PhidgetReturnCode;
4934}
4935#[repr(C)]
4936#[derive(Debug, Copy, Clone)]
4937pub struct _PhidgetDCMotor {
4938 _unused: [u8; 0],
4939}
4940pub type PhidgetDCMotorHandle = *mut _PhidgetDCMotor;
4941extern "C" {
4942 pub fn PhidgetDCMotor_create(ch: *mut PhidgetDCMotorHandle) -> PhidgetReturnCode;
4943}
4944extern "C" {
4945 pub fn PhidgetDCMotor_delete(ch: *mut PhidgetDCMotorHandle) -> PhidgetReturnCode;
4946}
4947extern "C" {
4948 pub fn PhidgetDCMotor_enableFailsafe(
4949 ch: PhidgetDCMotorHandle,
4950 failsafeTime: u32,
4951 ) -> PhidgetReturnCode;
4952}
4953extern "C" {
4954 pub fn PhidgetDCMotor_resetFailsafe(ch: PhidgetDCMotorHandle) -> PhidgetReturnCode;
4955}
4956extern "C" {
4957 pub fn PhidgetDCMotor_setAcceleration(
4958 ch: PhidgetDCMotorHandle,
4959 acceleration: f64,
4960 ) -> PhidgetReturnCode;
4961}
4962extern "C" {
4963 pub fn PhidgetDCMotor_getAcceleration(
4964 ch: PhidgetDCMotorHandle,
4965 acceleration: *mut f64,
4966 ) -> PhidgetReturnCode;
4967}
4968extern "C" {
4969 pub fn PhidgetDCMotor_getMinAcceleration(
4970 ch: PhidgetDCMotorHandle,
4971 minAcceleration: *mut f64,
4972 ) -> PhidgetReturnCode;
4973}
4974extern "C" {
4975 pub fn PhidgetDCMotor_getMaxAcceleration(
4976 ch: PhidgetDCMotorHandle,
4977 maxAcceleration: *mut f64,
4978 ) -> PhidgetReturnCode;
4979}
4980extern "C" {
4981 pub fn PhidgetDCMotor_getActiveCurrentLimit(
4982 ch: PhidgetDCMotorHandle,
4983 activeCurrentLimit: *mut f64,
4984 ) -> PhidgetReturnCode;
4985}
4986extern "C" {
4987 pub fn PhidgetDCMotor_getBackEMF(
4988 ch: PhidgetDCMotorHandle,
4989 backEMF: *mut f64,
4990 ) -> PhidgetReturnCode;
4991}
4992extern "C" {
4993 pub fn PhidgetDCMotor_setBackEMFSensingState(
4994 ch: PhidgetDCMotorHandle,
4995 backEMFSensingState: ::std::os::raw::c_int,
4996 ) -> PhidgetReturnCode;
4997}
4998extern "C" {
4999 pub fn PhidgetDCMotor_getBackEMFSensingState(
5000 ch: PhidgetDCMotorHandle,
5001 backEMFSensingState: *mut ::std::os::raw::c_int,
5002 ) -> PhidgetReturnCode;
5003}
5004extern "C" {
5005 pub fn PhidgetDCMotor_setBrakingEnabled(
5006 ch: PhidgetDCMotorHandle,
5007 brakingEnabled: ::std::os::raw::c_int,
5008 ) -> PhidgetReturnCode;
5009}
5010extern "C" {
5011 pub fn PhidgetDCMotor_getBrakingEnabled(
5012 ch: PhidgetDCMotorHandle,
5013 brakingEnabled: *mut ::std::os::raw::c_int,
5014 ) -> PhidgetReturnCode;
5015}
5016extern "C" {
5017 pub fn PhidgetDCMotor_getBrakingStrength(
5018 ch: PhidgetDCMotorHandle,
5019 brakingStrength: *mut f64,
5020 ) -> PhidgetReturnCode;
5021}
5022extern "C" {
5023 pub fn PhidgetDCMotor_getMinBrakingStrength(
5024 ch: PhidgetDCMotorHandle,
5025 minBrakingStrength: *mut f64,
5026 ) -> PhidgetReturnCode;
5027}
5028extern "C" {
5029 pub fn PhidgetDCMotor_getMaxBrakingStrength(
5030 ch: PhidgetDCMotorHandle,
5031 maxBrakingStrength: *mut f64,
5032 ) -> PhidgetReturnCode;
5033}
5034extern "C" {
5035 pub fn PhidgetDCMotor_setCurrentLimit(
5036 ch: PhidgetDCMotorHandle,
5037 currentLimit: f64,
5038 ) -> PhidgetReturnCode;
5039}
5040extern "C" {
5041 pub fn PhidgetDCMotor_getCurrentLimit(
5042 ch: PhidgetDCMotorHandle,
5043 currentLimit: *mut f64,
5044 ) -> PhidgetReturnCode;
5045}
5046extern "C" {
5047 pub fn PhidgetDCMotor_getMinCurrentLimit(
5048 ch: PhidgetDCMotorHandle,
5049 minCurrentLimit: *mut f64,
5050 ) -> PhidgetReturnCode;
5051}
5052extern "C" {
5053 pub fn PhidgetDCMotor_getMaxCurrentLimit(
5054 ch: PhidgetDCMotorHandle,
5055 maxCurrentLimit: *mut f64,
5056 ) -> PhidgetReturnCode;
5057}
5058extern "C" {
5059 pub fn PhidgetDCMotor_setCurrentRegulatorGain(
5060 ch: PhidgetDCMotorHandle,
5061 currentRegulatorGain: f64,
5062 ) -> PhidgetReturnCode;
5063}
5064extern "C" {
5065 pub fn PhidgetDCMotor_getCurrentRegulatorGain(
5066 ch: PhidgetDCMotorHandle,
5067 currentRegulatorGain: *mut f64,
5068 ) -> PhidgetReturnCode;
5069}
5070extern "C" {
5071 pub fn PhidgetDCMotor_getMinCurrentRegulatorGain(
5072 ch: PhidgetDCMotorHandle,
5073 minCurrentRegulatorGain: *mut f64,
5074 ) -> PhidgetReturnCode;
5075}
5076extern "C" {
5077 pub fn PhidgetDCMotor_getMaxCurrentRegulatorGain(
5078 ch: PhidgetDCMotorHandle,
5079 maxCurrentRegulatorGain: *mut f64,
5080 ) -> PhidgetReturnCode;
5081}
5082extern "C" {
5083 pub fn PhidgetDCMotor_setDataInterval(
5084 ch: PhidgetDCMotorHandle,
5085 dataInterval: u32,
5086 ) -> PhidgetReturnCode;
5087}
5088extern "C" {
5089 pub fn PhidgetDCMotor_getDataInterval(
5090 ch: PhidgetDCMotorHandle,
5091 dataInterval: *mut u32,
5092 ) -> PhidgetReturnCode;
5093}
5094extern "C" {
5095 pub fn PhidgetDCMotor_getMinDataInterval(
5096 ch: PhidgetDCMotorHandle,
5097 minDataInterval: *mut u32,
5098 ) -> PhidgetReturnCode;
5099}
5100extern "C" {
5101 pub fn PhidgetDCMotor_getMaxDataInterval(
5102 ch: PhidgetDCMotorHandle,
5103 maxDataInterval: *mut u32,
5104 ) -> PhidgetReturnCode;
5105}
5106extern "C" {
5107 pub fn PhidgetDCMotor_setDataRate(ch: PhidgetDCMotorHandle, dataRate: f64)
5108 -> PhidgetReturnCode;
5109}
5110extern "C" {
5111 pub fn PhidgetDCMotor_getDataRate(
5112 ch: PhidgetDCMotorHandle,
5113 dataRate: *mut f64,
5114 ) -> PhidgetReturnCode;
5115}
5116extern "C" {
5117 pub fn PhidgetDCMotor_getMinDataRate(
5118 ch: PhidgetDCMotorHandle,
5119 minDataRate: *mut f64,
5120 ) -> PhidgetReturnCode;
5121}
5122extern "C" {
5123 pub fn PhidgetDCMotor_getMaxDataRate(
5124 ch: PhidgetDCMotorHandle,
5125 maxDataRate: *mut f64,
5126 ) -> PhidgetReturnCode;
5127}
5128extern "C" {
5129 pub fn PhidgetDCMotor_setDriveMode(
5130 ch: PhidgetDCMotorHandle,
5131 driveMode: Phidget_DriveMode,
5132 ) -> PhidgetReturnCode;
5133}
5134extern "C" {
5135 pub fn PhidgetDCMotor_getDriveMode(
5136 ch: PhidgetDCMotorHandle,
5137 driveMode: *mut Phidget_DriveMode,
5138 ) -> PhidgetReturnCode;
5139}
5140extern "C" {
5141 pub fn PhidgetDCMotor_setFailsafeBrakingEnabled(
5142 ch: PhidgetDCMotorHandle,
5143 failsafeBrakingEnabled: ::std::os::raw::c_int,
5144 ) -> PhidgetReturnCode;
5145}
5146extern "C" {
5147 pub fn PhidgetDCMotor_getFailsafeBrakingEnabled(
5148 ch: PhidgetDCMotorHandle,
5149 failsafeBrakingEnabled: *mut ::std::os::raw::c_int,
5150 ) -> PhidgetReturnCode;
5151}
5152extern "C" {
5153 pub fn PhidgetDCMotor_setFailsafeCurrentLimit(
5154 ch: PhidgetDCMotorHandle,
5155 failsafeCurrentLimit: f64,
5156 ) -> PhidgetReturnCode;
5157}
5158extern "C" {
5159 pub fn PhidgetDCMotor_getFailsafeCurrentLimit(
5160 ch: PhidgetDCMotorHandle,
5161 failsafeCurrentLimit: *mut f64,
5162 ) -> PhidgetReturnCode;
5163}
5164extern "C" {
5165 pub fn PhidgetDCMotor_getMinFailsafeTime(
5166 ch: PhidgetDCMotorHandle,
5167 minFailsafeTime: *mut u32,
5168 ) -> PhidgetReturnCode;
5169}
5170extern "C" {
5171 pub fn PhidgetDCMotor_getMaxFailsafeTime(
5172 ch: PhidgetDCMotorHandle,
5173 maxFailsafeTime: *mut u32,
5174 ) -> PhidgetReturnCode;
5175}
5176extern "C" {
5177 pub fn PhidgetDCMotor_setFanMode(
5178 ch: PhidgetDCMotorHandle,
5179 fanMode: Phidget_FanMode,
5180 ) -> PhidgetReturnCode;
5181}
5182extern "C" {
5183 pub fn PhidgetDCMotor_getFanMode(
5184 ch: PhidgetDCMotorHandle,
5185 fanMode: *mut Phidget_FanMode,
5186 ) -> PhidgetReturnCode;
5187}
5188extern "C" {
5189 pub fn PhidgetDCMotor_setInductance(
5190 ch: PhidgetDCMotorHandle,
5191 inductance: f64,
5192 ) -> PhidgetReturnCode;
5193}
5194extern "C" {
5195 pub fn PhidgetDCMotor_getInductance(
5196 ch: PhidgetDCMotorHandle,
5197 inductance: *mut f64,
5198 ) -> PhidgetReturnCode;
5199}
5200extern "C" {
5201 pub fn PhidgetDCMotor_getMinInductance(
5202 ch: PhidgetDCMotorHandle,
5203 minInductance: *mut f64,
5204 ) -> PhidgetReturnCode;
5205}
5206extern "C" {
5207 pub fn PhidgetDCMotor_getMaxInductance(
5208 ch: PhidgetDCMotorHandle,
5209 maxInductance: *mut f64,
5210 ) -> PhidgetReturnCode;
5211}
5212extern "C" {
5213 pub fn PhidgetDCMotor_setSurgeCurrentLimit(
5214 ch: PhidgetDCMotorHandle,
5215 surgeCurrentLimit: f64,
5216 ) -> PhidgetReturnCode;
5217}
5218extern "C" {
5219 pub fn PhidgetDCMotor_getSurgeCurrentLimit(
5220 ch: PhidgetDCMotorHandle,
5221 surgeCurrentLimit: *mut f64,
5222 ) -> PhidgetReturnCode;
5223}
5224extern "C" {
5225 pub fn PhidgetDCMotor_getMinSurgeCurrentLimit(
5226 ch: PhidgetDCMotorHandle,
5227 minSurgeCurrentLimit: *mut f64,
5228 ) -> PhidgetReturnCode;
5229}
5230extern "C" {
5231 pub fn PhidgetDCMotor_getMaxSurgeCurrentLimit(
5232 ch: PhidgetDCMotorHandle,
5233 maxSurgeCurrentLimit: *mut f64,
5234 ) -> PhidgetReturnCode;
5235}
5236extern "C" {
5237 pub fn PhidgetDCMotor_setTargetBrakingStrength(
5238 ch: PhidgetDCMotorHandle,
5239 targetBrakingStrength: f64,
5240 ) -> PhidgetReturnCode;
5241}
5242extern "C" {
5243 pub fn PhidgetDCMotor_getTargetBrakingStrength(
5244 ch: PhidgetDCMotorHandle,
5245 targetBrakingStrength: *mut f64,
5246 ) -> PhidgetReturnCode;
5247}
5248extern "C" {
5249 pub fn PhidgetDCMotor_setTargetVelocity(
5250 ch: PhidgetDCMotorHandle,
5251 targetVelocity: f64,
5252 ) -> PhidgetReturnCode;
5253}
5254extern "C" {
5255 pub fn PhidgetDCMotor_setTargetVelocity_async(
5256 ch: PhidgetDCMotorHandle,
5257 targetVelocity: f64,
5258 fptr: Phidget_AsyncCallback,
5259 ctx: *mut ::std::os::raw::c_void,
5260 );
5261}
5262extern "C" {
5263 pub fn PhidgetDCMotor_getTargetVelocity(
5264 ch: PhidgetDCMotorHandle,
5265 targetVelocity: *mut f64,
5266 ) -> PhidgetReturnCode;
5267}
5268extern "C" {
5269 pub fn PhidgetDCMotor_getVelocity(
5270 ch: PhidgetDCMotorHandle,
5271 velocity: *mut f64,
5272 ) -> PhidgetReturnCode;
5273}
5274extern "C" {
5275 pub fn PhidgetDCMotor_getMinVelocity(
5276 ch: PhidgetDCMotorHandle,
5277 minVelocity: *mut f64,
5278 ) -> PhidgetReturnCode;
5279}
5280extern "C" {
5281 pub fn PhidgetDCMotor_getMaxVelocity(
5282 ch: PhidgetDCMotorHandle,
5283 maxVelocity: *mut f64,
5284 ) -> PhidgetReturnCode;
5285}
5286pub type PhidgetDCMotor_OnBackEMFChangeCallback = ::std::option::Option<
5287 unsafe extern "C" fn(ch: PhidgetDCMotorHandle, ctx: *mut ::std::os::raw::c_void, backEMF: f64),
5288>;
5289extern "C" {
5290 pub fn PhidgetDCMotor_setOnBackEMFChangeHandler(
5291 ch: PhidgetDCMotorHandle,
5292 fptr: PhidgetDCMotor_OnBackEMFChangeCallback,
5293 ctx: *mut ::std::os::raw::c_void,
5294 ) -> PhidgetReturnCode;
5295}
5296pub type PhidgetDCMotor_OnBrakingStrengthChangeCallback = ::std::option::Option<
5297 unsafe extern "C" fn(
5298 ch: PhidgetDCMotorHandle,
5299 ctx: *mut ::std::os::raw::c_void,
5300 brakingStrength: f64,
5301 ),
5302>;
5303extern "C" {
5304 pub fn PhidgetDCMotor_setOnBrakingStrengthChangeHandler(
5305 ch: PhidgetDCMotorHandle,
5306 fptr: PhidgetDCMotor_OnBrakingStrengthChangeCallback,
5307 ctx: *mut ::std::os::raw::c_void,
5308 ) -> PhidgetReturnCode;
5309}
5310pub type PhidgetDCMotor_OnVelocityUpdateCallback = ::std::option::Option<
5311 unsafe extern "C" fn(ch: PhidgetDCMotorHandle, ctx: *mut ::std::os::raw::c_void, velocity: f64),
5312>;
5313extern "C" {
5314 pub fn PhidgetDCMotor_setOnVelocityUpdateHandler(
5315 ch: PhidgetDCMotorHandle,
5316 fptr: PhidgetDCMotor_OnVelocityUpdateCallback,
5317 ctx: *mut ::std::os::raw::c_void,
5318 ) -> PhidgetReturnCode;
5319}
5320#[repr(C)]
5321#[derive(Debug, Copy, Clone)]
5322pub struct _PhidgetDataAdapter {
5323 _unused: [u8; 0],
5324}
5325pub type PhidgetDataAdapterHandle = *mut _PhidgetDataAdapter;
5326extern "C" {
5327 pub fn PhidgetDataAdapter_create(ch: *mut PhidgetDataAdapterHandle) -> PhidgetReturnCode;
5328}
5329extern "C" {
5330 pub fn PhidgetDataAdapter_delete(ch: *mut PhidgetDataAdapterHandle) -> PhidgetReturnCode;
5331}
5332extern "C" {
5333 pub fn PhidgetDataAdapter_i2cComplexTransaction(
5334 ch: PhidgetDataAdapterHandle,
5335 address: i32,
5336 I2CPacketString: *mut ::std::os::raw::c_char,
5337 data: *const u8,
5338 sendDataLen: usize,
5339 recvData: *mut u8,
5340 recvDataLen: *mut usize,
5341 ) -> PhidgetReturnCode;
5342}
5343extern "C" {
5344 pub fn PhidgetDataAdapter_i2cSendReceive(
5345 ch: PhidgetDataAdapterHandle,
5346 address: i32,
5347 data: *const u8,
5348 sendDataLen: usize,
5349 recvData: *mut u8,
5350 recvDataLen: usize,
5351 ) -> PhidgetReturnCode;
5352}
5353extern "C" {
5354 pub fn PhidgetDataAdapter_sendPacket(
5355 ch: PhidgetDataAdapterHandle,
5356 data: *const u8,
5357 dataLen: usize,
5358 ) -> PhidgetReturnCode;
5359}
5360extern "C" {
5361 pub fn PhidgetDataAdapter_sendPacketWaitResponse(
5362 ch: PhidgetDataAdapterHandle,
5363 data: *const u8,
5364 sendDataLen: usize,
5365 recvData: *mut u8,
5366 recvDataLen: *mut usize,
5367 ) -> PhidgetReturnCode;
5368}
5369extern "C" {
5370 pub fn PhidgetDataAdapter_setDataAdapterVoltage(
5371 ch: PhidgetDataAdapterHandle,
5372 dataAdapterVoltage: Phidget_DataAdapterVoltage,
5373 ) -> PhidgetReturnCode;
5374}
5375extern "C" {
5376 pub fn PhidgetDataAdapter_getDataAdapterVoltage(
5377 ch: PhidgetDataAdapterHandle,
5378 dataAdapterVoltage: *mut Phidget_DataAdapterVoltage,
5379 ) -> PhidgetReturnCode;
5380}
5381extern "C" {
5382 pub fn PhidgetDataAdapter_setDataBits(
5383 ch: PhidgetDataAdapterHandle,
5384 dataBits: u32,
5385 ) -> PhidgetReturnCode;
5386}
5387extern "C" {
5388 pub fn PhidgetDataAdapter_getDataBits(
5389 ch: PhidgetDataAdapterHandle,
5390 dataBits: *mut u32,
5391 ) -> PhidgetReturnCode;
5392}
5393extern "C" {
5394 pub fn PhidgetDataAdapter_getMinDataBits(
5395 ch: PhidgetDataAdapterHandle,
5396 minDataBits: *mut u32,
5397 ) -> PhidgetReturnCode;
5398}
5399extern "C" {
5400 pub fn PhidgetDataAdapter_getMaxDataBits(
5401 ch: PhidgetDataAdapterHandle,
5402 maxDataBits: *mut u32,
5403 ) -> PhidgetReturnCode;
5404}
5405extern "C" {
5406 pub fn PhidgetDataAdapter_setFrequency(
5407 ch: PhidgetDataAdapterHandle,
5408 frequency: PhidgetDataAdapter_Frequency,
5409 ) -> PhidgetReturnCode;
5410}
5411extern "C" {
5412 pub fn PhidgetDataAdapter_getFrequency(
5413 ch: PhidgetDataAdapterHandle,
5414 frequency: *mut PhidgetDataAdapter_Frequency,
5415 ) -> PhidgetReturnCode;
5416}
5417extern "C" {
5418 pub fn PhidgetDataAdapter_setEndianness(
5419 ch: PhidgetDataAdapterHandle,
5420 endianness: PhidgetDataAdapter_Endianness,
5421 ) -> PhidgetReturnCode;
5422}
5423extern "C" {
5424 pub fn PhidgetDataAdapter_getEndianness(
5425 ch: PhidgetDataAdapterHandle,
5426 endianness: *mut PhidgetDataAdapter_Endianness,
5427 ) -> PhidgetReturnCode;
5428}
5429extern "C" {
5430 pub fn PhidgetDataAdapter_getMaxReceivePacketLength(
5431 ch: PhidgetDataAdapterHandle,
5432 maxReceivePacketLength: *mut u32,
5433 ) -> PhidgetReturnCode;
5434}
5435extern "C" {
5436 pub fn PhidgetDataAdapter_getMaxSendPacketLength(
5437 ch: PhidgetDataAdapterHandle,
5438 maxSendPacketLength: *mut u32,
5439 ) -> PhidgetReturnCode;
5440}
5441extern "C" {
5442 pub fn PhidgetDataAdapter_setSPIChipSelect(
5443 ch: PhidgetDataAdapterHandle,
5444 SPIChipSelect: PhidgetDataAdapter_SPIChipSelect,
5445 ) -> PhidgetReturnCode;
5446}
5447extern "C" {
5448 pub fn PhidgetDataAdapter_getSPIChipSelect(
5449 ch: PhidgetDataAdapterHandle,
5450 SPIChipSelect: *mut PhidgetDataAdapter_SPIChipSelect,
5451 ) -> PhidgetReturnCode;
5452}
5453extern "C" {
5454 pub fn PhidgetDataAdapter_setSPIMode(
5455 ch: PhidgetDataAdapterHandle,
5456 SPIMode: PhidgetDataAdapter_SPIMode,
5457 ) -> PhidgetReturnCode;
5458}
5459extern "C" {
5460 pub fn PhidgetDataAdapter_getSPIMode(
5461 ch: PhidgetDataAdapterHandle,
5462 SPIMode: *mut PhidgetDataAdapter_SPIMode,
5463 ) -> PhidgetReturnCode;
5464}
5465#[repr(C)]
5466#[derive(Debug, Copy, Clone)]
5467pub struct _PhidgetDictionary {
5468 _unused: [u8; 0],
5469}
5470pub type PhidgetDictionaryHandle = *mut _PhidgetDictionary;
5471extern "C" {
5472 pub fn PhidgetDictionary_enableControlDictionary() -> PhidgetReturnCode;
5473}
5474extern "C" {
5475 pub fn PhidgetDictionary_addDictionary(
5476 deviceSerialNumber: ::std::os::raw::c_int,
5477 label: *const ::std::os::raw::c_char,
5478 ) -> PhidgetReturnCode;
5479}
5480extern "C" {
5481 pub fn PhidgetDictionary_removeDictionary(
5482 deviceSerialNumber: ::std::os::raw::c_int,
5483 ) -> PhidgetReturnCode;
5484}
5485extern "C" {
5486 pub fn PhidgetDictionary_loadDictionary(
5487 dictionarySerialNumber: ::std::os::raw::c_int,
5488 file: *const ::std::os::raw::c_char,
5489 ) -> PhidgetReturnCode;
5490}
5491extern "C" {
5492 pub fn PhidgetDictionary_enableStatsDictionary() -> PhidgetReturnCode;
5493}
5494extern "C" {
5495 pub fn PhidgetDictionary_create(ch: *mut PhidgetDictionaryHandle) -> PhidgetReturnCode;
5496}
5497extern "C" {
5498 pub fn PhidgetDictionary_delete(ch: *mut PhidgetDictionaryHandle) -> PhidgetReturnCode;
5499}
5500extern "C" {
5501 pub fn PhidgetDictionary_add(
5502 ch: PhidgetDictionaryHandle,
5503 key: *const ::std::os::raw::c_char,
5504 value: *const ::std::os::raw::c_char,
5505 ) -> PhidgetReturnCode;
5506}
5507extern "C" {
5508 pub fn PhidgetDictionary_removeAll(ch: PhidgetDictionaryHandle) -> PhidgetReturnCode;
5509}
5510extern "C" {
5511 pub fn PhidgetDictionary_get(
5512 ch: PhidgetDictionaryHandle,
5513 key: *const ::std::os::raw::c_char,
5514 value: *mut ::std::os::raw::c_char,
5515 valueLen: usize,
5516 ) -> PhidgetReturnCode;
5517}
5518extern "C" {
5519 pub fn PhidgetDictionary_remove(
5520 ch: PhidgetDictionaryHandle,
5521 key: *const ::std::os::raw::c_char,
5522 ) -> PhidgetReturnCode;
5523}
5524extern "C" {
5525 pub fn PhidgetDictionary_scan(
5526 ch: PhidgetDictionaryHandle,
5527 start: *const ::std::os::raw::c_char,
5528 keyList: *mut ::std::os::raw::c_char,
5529 keyListLen: usize,
5530 ) -> PhidgetReturnCode;
5531}
5532extern "C" {
5533 pub fn PhidgetDictionary_set(
5534 ch: PhidgetDictionaryHandle,
5535 key: *const ::std::os::raw::c_char,
5536 value: *const ::std::os::raw::c_char,
5537 ) -> PhidgetReturnCode;
5538}
5539extern "C" {
5540 pub fn PhidgetDictionary_update(
5541 ch: PhidgetDictionaryHandle,
5542 key: *const ::std::os::raw::c_char,
5543 value: *const ::std::os::raw::c_char,
5544 ) -> PhidgetReturnCode;
5545}
5546pub type PhidgetDictionary_OnAddCallback = ::std::option::Option<
5547 unsafe extern "C" fn(
5548 ch: PhidgetDictionaryHandle,
5549 ctx: *mut ::std::os::raw::c_void,
5550 key: *const ::std::os::raw::c_char,
5551 value: *const ::std::os::raw::c_char,
5552 ),
5553>;
5554extern "C" {
5555 pub fn PhidgetDictionary_setOnAddHandler(
5556 ch: PhidgetDictionaryHandle,
5557 fptr: PhidgetDictionary_OnAddCallback,
5558 ctx: *mut ::std::os::raw::c_void,
5559 ) -> PhidgetReturnCode;
5560}
5561pub type PhidgetDictionary_OnRemoveCallback = ::std::option::Option<
5562 unsafe extern "C" fn(
5563 ch: PhidgetDictionaryHandle,
5564 ctx: *mut ::std::os::raw::c_void,
5565 key: *const ::std::os::raw::c_char,
5566 ),
5567>;
5568extern "C" {
5569 pub fn PhidgetDictionary_setOnRemoveHandler(
5570 ch: PhidgetDictionaryHandle,
5571 fptr: PhidgetDictionary_OnRemoveCallback,
5572 ctx: *mut ::std::os::raw::c_void,
5573 ) -> PhidgetReturnCode;
5574}
5575pub type PhidgetDictionary_OnUpdateCallback = ::std::option::Option<
5576 unsafe extern "C" fn(
5577 ch: PhidgetDictionaryHandle,
5578 ctx: *mut ::std::os::raw::c_void,
5579 key: *const ::std::os::raw::c_char,
5580 value: *const ::std::os::raw::c_char,
5581 ),
5582>;
5583extern "C" {
5584 pub fn PhidgetDictionary_setOnUpdateHandler(
5585 ch: PhidgetDictionaryHandle,
5586 fptr: PhidgetDictionary_OnUpdateCallback,
5587 ctx: *mut ::std::os::raw::c_void,
5588 ) -> PhidgetReturnCode;
5589}
5590#[repr(C)]
5591#[derive(Debug, Copy, Clone)]
5592pub struct _PhidgetDigitalInput {
5593 _unused: [u8; 0],
5594}
5595pub type PhidgetDigitalInputHandle = *mut _PhidgetDigitalInput;
5596extern "C" {
5597 pub fn PhidgetDigitalInput_create(ch: *mut PhidgetDigitalInputHandle) -> PhidgetReturnCode;
5598}
5599extern "C" {
5600 pub fn PhidgetDigitalInput_delete(ch: *mut PhidgetDigitalInputHandle) -> PhidgetReturnCode;
5601}
5602extern "C" {
5603 pub fn PhidgetDigitalInput_setInputMode(
5604 ch: PhidgetDigitalInputHandle,
5605 inputMode: Phidget_InputMode,
5606 ) -> PhidgetReturnCode;
5607}
5608extern "C" {
5609 pub fn PhidgetDigitalInput_getInputMode(
5610 ch: PhidgetDigitalInputHandle,
5611 inputMode: *mut Phidget_InputMode,
5612 ) -> PhidgetReturnCode;
5613}
5614extern "C" {
5615 pub fn PhidgetDigitalInput_setPowerSupply(
5616 ch: PhidgetDigitalInputHandle,
5617 powerSupply: Phidget_PowerSupply,
5618 ) -> PhidgetReturnCode;
5619}
5620extern "C" {
5621 pub fn PhidgetDigitalInput_getPowerSupply(
5622 ch: PhidgetDigitalInputHandle,
5623 powerSupply: *mut Phidget_PowerSupply,
5624 ) -> PhidgetReturnCode;
5625}
5626extern "C" {
5627 pub fn PhidgetDigitalInput_getState(
5628 ch: PhidgetDigitalInputHandle,
5629 state: *mut ::std::os::raw::c_int,
5630 ) -> PhidgetReturnCode;
5631}
5632pub type PhidgetDigitalInput_OnStateChangeCallback = ::std::option::Option<
5633 unsafe extern "C" fn(
5634 ch: PhidgetDigitalInputHandle,
5635 ctx: *mut ::std::os::raw::c_void,
5636 state: ::std::os::raw::c_int,
5637 ),
5638>;
5639extern "C" {
5640 pub fn PhidgetDigitalInput_setOnStateChangeHandler(
5641 ch: PhidgetDigitalInputHandle,
5642 fptr: PhidgetDigitalInput_OnStateChangeCallback,
5643 ctx: *mut ::std::os::raw::c_void,
5644 ) -> PhidgetReturnCode;
5645}
5646#[repr(C)]
5647#[derive(Debug, Copy, Clone)]
5648pub struct _PhidgetDigitalOutput {
5649 _unused: [u8; 0],
5650}
5651pub type PhidgetDigitalOutputHandle = *mut _PhidgetDigitalOutput;
5652extern "C" {
5653 pub fn PhidgetDigitalOutput_create(ch: *mut PhidgetDigitalOutputHandle) -> PhidgetReturnCode;
5654}
5655extern "C" {
5656 pub fn PhidgetDigitalOutput_delete(ch: *mut PhidgetDigitalOutputHandle) -> PhidgetReturnCode;
5657}
5658extern "C" {
5659 pub fn PhidgetDigitalOutput_enableFailsafe(
5660 ch: PhidgetDigitalOutputHandle,
5661 failsafeTime: u32,
5662 ) -> PhidgetReturnCode;
5663}
5664extern "C" {
5665 pub fn PhidgetDigitalOutput_resetFailsafe(ch: PhidgetDigitalOutputHandle) -> PhidgetReturnCode;
5666}
5667extern "C" {
5668 pub fn PhidgetDigitalOutput_setDutyCycle(
5669 ch: PhidgetDigitalOutputHandle,
5670 dutyCycle: f64,
5671 ) -> PhidgetReturnCode;
5672}
5673extern "C" {
5674 pub fn PhidgetDigitalOutput_setDutyCycle_async(
5675 ch: PhidgetDigitalOutputHandle,
5676 dutyCycle: f64,
5677 fptr: Phidget_AsyncCallback,
5678 ctx: *mut ::std::os::raw::c_void,
5679 );
5680}
5681extern "C" {
5682 pub fn PhidgetDigitalOutput_getDutyCycle(
5683 ch: PhidgetDigitalOutputHandle,
5684 dutyCycle: *mut f64,
5685 ) -> PhidgetReturnCode;
5686}
5687extern "C" {
5688 pub fn PhidgetDigitalOutput_getMinDutyCycle(
5689 ch: PhidgetDigitalOutputHandle,
5690 minDutyCycle: *mut f64,
5691 ) -> PhidgetReturnCode;
5692}
5693extern "C" {
5694 pub fn PhidgetDigitalOutput_getMaxDutyCycle(
5695 ch: PhidgetDigitalOutputHandle,
5696 maxDutyCycle: *mut f64,
5697 ) -> PhidgetReturnCode;
5698}
5699extern "C" {
5700 pub fn PhidgetDigitalOutput_getMinFailsafeTime(
5701 ch: PhidgetDigitalOutputHandle,
5702 minFailsafeTime: *mut u32,
5703 ) -> PhidgetReturnCode;
5704}
5705extern "C" {
5706 pub fn PhidgetDigitalOutput_getMaxFailsafeTime(
5707 ch: PhidgetDigitalOutputHandle,
5708 maxFailsafeTime: *mut u32,
5709 ) -> PhidgetReturnCode;
5710}
5711extern "C" {
5712 pub fn PhidgetDigitalOutput_setFrequency(
5713 ch: PhidgetDigitalOutputHandle,
5714 frequency: f64,
5715 ) -> PhidgetReturnCode;
5716}
5717extern "C" {
5718 pub fn PhidgetDigitalOutput_getFrequency(
5719 ch: PhidgetDigitalOutputHandle,
5720 frequency: *mut f64,
5721 ) -> PhidgetReturnCode;
5722}
5723extern "C" {
5724 pub fn PhidgetDigitalOutput_getMinFrequency(
5725 ch: PhidgetDigitalOutputHandle,
5726 minFrequency: *mut f64,
5727 ) -> PhidgetReturnCode;
5728}
5729extern "C" {
5730 pub fn PhidgetDigitalOutput_getMaxFrequency(
5731 ch: PhidgetDigitalOutputHandle,
5732 maxFrequency: *mut f64,
5733 ) -> PhidgetReturnCode;
5734}
5735extern "C" {
5736 pub fn PhidgetDigitalOutput_setLEDCurrentLimit(
5737 ch: PhidgetDigitalOutputHandle,
5738 LEDCurrentLimit: f64,
5739 ) -> PhidgetReturnCode;
5740}
5741extern "C" {
5742 pub fn PhidgetDigitalOutput_setLEDCurrentLimit_async(
5743 ch: PhidgetDigitalOutputHandle,
5744 LEDCurrentLimit: f64,
5745 fptr: Phidget_AsyncCallback,
5746 ctx: *mut ::std::os::raw::c_void,
5747 );
5748}
5749extern "C" {
5750 pub fn PhidgetDigitalOutput_getLEDCurrentLimit(
5751 ch: PhidgetDigitalOutputHandle,
5752 LEDCurrentLimit: *mut f64,
5753 ) -> PhidgetReturnCode;
5754}
5755extern "C" {
5756 pub fn PhidgetDigitalOutput_getMinLEDCurrentLimit(
5757 ch: PhidgetDigitalOutputHandle,
5758 minLEDCurrentLimit: *mut f64,
5759 ) -> PhidgetReturnCode;
5760}
5761extern "C" {
5762 pub fn PhidgetDigitalOutput_getMaxLEDCurrentLimit(
5763 ch: PhidgetDigitalOutputHandle,
5764 maxLEDCurrentLimit: *mut f64,
5765 ) -> PhidgetReturnCode;
5766}
5767extern "C" {
5768 pub fn PhidgetDigitalOutput_setLEDForwardVoltage(
5769 ch: PhidgetDigitalOutputHandle,
5770 LEDForwardVoltage: PhidgetDigitalOutput_LEDForwardVoltage,
5771 ) -> PhidgetReturnCode;
5772}
5773extern "C" {
5774 pub fn PhidgetDigitalOutput_getLEDForwardVoltage(
5775 ch: PhidgetDigitalOutputHandle,
5776 LEDForwardVoltage: *mut PhidgetDigitalOutput_LEDForwardVoltage,
5777 ) -> PhidgetReturnCode;
5778}
5779extern "C" {
5780 pub fn PhidgetDigitalOutput_setState(
5781 ch: PhidgetDigitalOutputHandle,
5782 state: ::std::os::raw::c_int,
5783 ) -> PhidgetReturnCode;
5784}
5785extern "C" {
5786 pub fn PhidgetDigitalOutput_setState_async(
5787 ch: PhidgetDigitalOutputHandle,
5788 state: ::std::os::raw::c_int,
5789 fptr: Phidget_AsyncCallback,
5790 ctx: *mut ::std::os::raw::c_void,
5791 );
5792}
5793extern "C" {
5794 pub fn PhidgetDigitalOutput_getState(
5795 ch: PhidgetDigitalOutputHandle,
5796 state: *mut ::std::os::raw::c_int,
5797 ) -> PhidgetReturnCode;
5798}
5799#[repr(C)]
5800#[derive(Debug, Copy, Clone)]
5801pub struct _PhidgetDistanceSensor {
5802 _unused: [u8; 0],
5803}
5804pub type PhidgetDistanceSensorHandle = *mut _PhidgetDistanceSensor;
5805extern "C" {
5806 pub fn PhidgetDistanceSensor_create(ch: *mut PhidgetDistanceSensorHandle) -> PhidgetReturnCode;
5807}
5808extern "C" {
5809 pub fn PhidgetDistanceSensor_delete(ch: *mut PhidgetDistanceSensorHandle) -> PhidgetReturnCode;
5810}
5811extern "C" {
5812 pub fn PhidgetDistanceSensor_getSonarReflections(
5813 ch: PhidgetDistanceSensorHandle,
5814 distances: *mut [u32; 8usize],
5815 amplitudes: *mut [u32; 8usize],
5816 count: *mut u32,
5817 ) -> PhidgetReturnCode;
5818}
5819extern "C" {
5820 pub fn PhidgetDistanceSensor_setDataInterval(
5821 ch: PhidgetDistanceSensorHandle,
5822 dataInterval: u32,
5823 ) -> PhidgetReturnCode;
5824}
5825extern "C" {
5826 pub fn PhidgetDistanceSensor_getDataInterval(
5827 ch: PhidgetDistanceSensorHandle,
5828 dataInterval: *mut u32,
5829 ) -> PhidgetReturnCode;
5830}
5831extern "C" {
5832 pub fn PhidgetDistanceSensor_getMinDataInterval(
5833 ch: PhidgetDistanceSensorHandle,
5834 minDataInterval: *mut u32,
5835 ) -> PhidgetReturnCode;
5836}
5837extern "C" {
5838 pub fn PhidgetDistanceSensor_getMaxDataInterval(
5839 ch: PhidgetDistanceSensorHandle,
5840 maxDataInterval: *mut u32,
5841 ) -> PhidgetReturnCode;
5842}
5843extern "C" {
5844 pub fn PhidgetDistanceSensor_setDataRate(
5845 ch: PhidgetDistanceSensorHandle,
5846 dataRate: f64,
5847 ) -> PhidgetReturnCode;
5848}
5849extern "C" {
5850 pub fn PhidgetDistanceSensor_getDataRate(
5851 ch: PhidgetDistanceSensorHandle,
5852 dataRate: *mut f64,
5853 ) -> PhidgetReturnCode;
5854}
5855extern "C" {
5856 pub fn PhidgetDistanceSensor_getMinDataRate(
5857 ch: PhidgetDistanceSensorHandle,
5858 minDataRate: *mut f64,
5859 ) -> PhidgetReturnCode;
5860}
5861extern "C" {
5862 pub fn PhidgetDistanceSensor_getMaxDataRate(
5863 ch: PhidgetDistanceSensorHandle,
5864 maxDataRate: *mut f64,
5865 ) -> PhidgetReturnCode;
5866}
5867extern "C" {
5868 pub fn PhidgetDistanceSensor_getDistance(
5869 ch: PhidgetDistanceSensorHandle,
5870 distance: *mut u32,
5871 ) -> PhidgetReturnCode;
5872}
5873extern "C" {
5874 pub fn PhidgetDistanceSensor_getMinDistance(
5875 ch: PhidgetDistanceSensorHandle,
5876 minDistance: *mut u32,
5877 ) -> PhidgetReturnCode;
5878}
5879extern "C" {
5880 pub fn PhidgetDistanceSensor_getMaxDistance(
5881 ch: PhidgetDistanceSensorHandle,
5882 maxDistance: *mut u32,
5883 ) -> PhidgetReturnCode;
5884}
5885extern "C" {
5886 pub fn PhidgetDistanceSensor_setDistanceChangeTrigger(
5887 ch: PhidgetDistanceSensorHandle,
5888 distanceChangeTrigger: u32,
5889 ) -> PhidgetReturnCode;
5890}
5891extern "C" {
5892 pub fn PhidgetDistanceSensor_getDistanceChangeTrigger(
5893 ch: PhidgetDistanceSensorHandle,
5894 distanceChangeTrigger: *mut u32,
5895 ) -> PhidgetReturnCode;
5896}
5897extern "C" {
5898 pub fn PhidgetDistanceSensor_getMinDistanceChangeTrigger(
5899 ch: PhidgetDistanceSensorHandle,
5900 minDistanceChangeTrigger: *mut u32,
5901 ) -> PhidgetReturnCode;
5902}
5903extern "C" {
5904 pub fn PhidgetDistanceSensor_getMaxDistanceChangeTrigger(
5905 ch: PhidgetDistanceSensorHandle,
5906 maxDistanceChangeTrigger: *mut u32,
5907 ) -> PhidgetReturnCode;
5908}
5909extern "C" {
5910 pub fn PhidgetDistanceSensor_setSonarQuietMode(
5911 ch: PhidgetDistanceSensorHandle,
5912 sonarQuietMode: ::std::os::raw::c_int,
5913 ) -> PhidgetReturnCode;
5914}
5915extern "C" {
5916 pub fn PhidgetDistanceSensor_getSonarQuietMode(
5917 ch: PhidgetDistanceSensorHandle,
5918 sonarQuietMode: *mut ::std::os::raw::c_int,
5919 ) -> PhidgetReturnCode;
5920}
5921pub type PhidgetDistanceSensor_OnDistanceChangeCallback = ::std::option::Option<
5922 unsafe extern "C" fn(
5923 ch: PhidgetDistanceSensorHandle,
5924 ctx: *mut ::std::os::raw::c_void,
5925 distance: u32,
5926 ),
5927>;
5928extern "C" {
5929 pub fn PhidgetDistanceSensor_setOnDistanceChangeHandler(
5930 ch: PhidgetDistanceSensorHandle,
5931 fptr: PhidgetDistanceSensor_OnDistanceChangeCallback,
5932 ctx: *mut ::std::os::raw::c_void,
5933 ) -> PhidgetReturnCode;
5934}
5935pub type PhidgetDistanceSensor_OnSonarReflectionsUpdateCallback = ::std::option::Option<
5936 unsafe extern "C" fn(
5937 ch: PhidgetDistanceSensorHandle,
5938 ctx: *mut ::std::os::raw::c_void,
5939 distances: *const u32,
5940 amplitudes: *const u32,
5941 count: u32,
5942 ),
5943>;
5944extern "C" {
5945 pub fn PhidgetDistanceSensor_setOnSonarReflectionsUpdateHandler(
5946 ch: PhidgetDistanceSensorHandle,
5947 fptr: PhidgetDistanceSensor_OnSonarReflectionsUpdateCallback,
5948 ctx: *mut ::std::os::raw::c_void,
5949 ) -> PhidgetReturnCode;
5950}
5951#[repr(C)]
5952#[derive(Debug, Copy, Clone)]
5953pub struct _PhidgetEncoder {
5954 _unused: [u8; 0],
5955}
5956pub type PhidgetEncoderHandle = *mut _PhidgetEncoder;
5957extern "C" {
5958 pub fn PhidgetEncoder_create(ch: *mut PhidgetEncoderHandle) -> PhidgetReturnCode;
5959}
5960extern "C" {
5961 pub fn PhidgetEncoder_delete(ch: *mut PhidgetEncoderHandle) -> PhidgetReturnCode;
5962}
5963extern "C" {
5964 pub fn PhidgetEncoder_setEnabled(
5965 ch: PhidgetEncoderHandle,
5966 enabled: ::std::os::raw::c_int,
5967 ) -> PhidgetReturnCode;
5968}
5969extern "C" {
5970 pub fn PhidgetEncoder_getEnabled(
5971 ch: PhidgetEncoderHandle,
5972 enabled: *mut ::std::os::raw::c_int,
5973 ) -> PhidgetReturnCode;
5974}
5975extern "C" {
5976 pub fn PhidgetEncoder_setDataInterval(
5977 ch: PhidgetEncoderHandle,
5978 dataInterval: u32,
5979 ) -> PhidgetReturnCode;
5980}
5981extern "C" {
5982 pub fn PhidgetEncoder_getDataInterval(
5983 ch: PhidgetEncoderHandle,
5984 dataInterval: *mut u32,
5985 ) -> PhidgetReturnCode;
5986}
5987extern "C" {
5988 pub fn PhidgetEncoder_getMinDataInterval(
5989 ch: PhidgetEncoderHandle,
5990 minDataInterval: *mut u32,
5991 ) -> PhidgetReturnCode;
5992}
5993extern "C" {
5994 pub fn PhidgetEncoder_getMaxDataInterval(
5995 ch: PhidgetEncoderHandle,
5996 maxDataInterval: *mut u32,
5997 ) -> PhidgetReturnCode;
5998}
5999extern "C" {
6000 pub fn PhidgetEncoder_setDataRate(ch: PhidgetEncoderHandle, dataRate: f64)
6001 -> PhidgetReturnCode;
6002}
6003extern "C" {
6004 pub fn PhidgetEncoder_getDataRate(
6005 ch: PhidgetEncoderHandle,
6006 dataRate: *mut f64,
6007 ) -> PhidgetReturnCode;
6008}
6009extern "C" {
6010 pub fn PhidgetEncoder_getMinDataRate(
6011 ch: PhidgetEncoderHandle,
6012 minDataRate: *mut f64,
6013 ) -> PhidgetReturnCode;
6014}
6015extern "C" {
6016 pub fn PhidgetEncoder_getMaxDataRate(
6017 ch: PhidgetEncoderHandle,
6018 maxDataRate: *mut f64,
6019 ) -> PhidgetReturnCode;
6020}
6021extern "C" {
6022 pub fn PhidgetEncoder_getIndexPosition(
6023 ch: PhidgetEncoderHandle,
6024 indexPosition: *mut i64,
6025 ) -> PhidgetReturnCode;
6026}
6027extern "C" {
6028 pub fn PhidgetEncoder_setIOMode(
6029 ch: PhidgetEncoderHandle,
6030 IOMode: Phidget_EncoderIOMode,
6031 ) -> PhidgetReturnCode;
6032}
6033extern "C" {
6034 pub fn PhidgetEncoder_getIOMode(
6035 ch: PhidgetEncoderHandle,
6036 IOMode: *mut Phidget_EncoderIOMode,
6037 ) -> PhidgetReturnCode;
6038}
6039extern "C" {
6040 pub fn PhidgetEncoder_setPosition(ch: PhidgetEncoderHandle, position: i64)
6041 -> PhidgetReturnCode;
6042}
6043extern "C" {
6044 pub fn PhidgetEncoder_getPosition(
6045 ch: PhidgetEncoderHandle,
6046 position: *mut i64,
6047 ) -> PhidgetReturnCode;
6048}
6049extern "C" {
6050 pub fn PhidgetEncoder_setPositionChangeTrigger(
6051 ch: PhidgetEncoderHandle,
6052 positionChangeTrigger: u32,
6053 ) -> PhidgetReturnCode;
6054}
6055extern "C" {
6056 pub fn PhidgetEncoder_getPositionChangeTrigger(
6057 ch: PhidgetEncoderHandle,
6058 positionChangeTrigger: *mut u32,
6059 ) -> PhidgetReturnCode;
6060}
6061extern "C" {
6062 pub fn PhidgetEncoder_getMinPositionChangeTrigger(
6063 ch: PhidgetEncoderHandle,
6064 minPositionChangeTrigger: *mut u32,
6065 ) -> PhidgetReturnCode;
6066}
6067extern "C" {
6068 pub fn PhidgetEncoder_getMaxPositionChangeTrigger(
6069 ch: PhidgetEncoderHandle,
6070 maxPositionChangeTrigger: *mut u32,
6071 ) -> PhidgetReturnCode;
6072}
6073pub type PhidgetEncoder_OnPositionChangeCallback = ::std::option::Option<
6074 unsafe extern "C" fn(
6075 ch: PhidgetEncoderHandle,
6076 ctx: *mut ::std::os::raw::c_void,
6077 positionChange: ::std::os::raw::c_int,
6078 timeChange: f64,
6079 indexTriggered: ::std::os::raw::c_int,
6080 ),
6081>;
6082extern "C" {
6083 pub fn PhidgetEncoder_setOnPositionChangeHandler(
6084 ch: PhidgetEncoderHandle,
6085 fptr: PhidgetEncoder_OnPositionChangeCallback,
6086 ctx: *mut ::std::os::raw::c_void,
6087 ) -> PhidgetReturnCode;
6088}
6089#[repr(C)]
6090#[derive(Debug, Copy, Clone)]
6091pub struct _PhidgetFirmwareUpgrade {
6092 _unused: [u8; 0],
6093}
6094pub type PhidgetFirmwareUpgradeHandle = *mut _PhidgetFirmwareUpgrade;
6095extern "C" {
6096 pub fn PhidgetFirmwareUpgrade_create(
6097 ch: *mut PhidgetFirmwareUpgradeHandle,
6098 ) -> PhidgetReturnCode;
6099}
6100extern "C" {
6101 pub fn PhidgetFirmwareUpgrade_delete(
6102 ch: *mut PhidgetFirmwareUpgradeHandle,
6103 ) -> PhidgetReturnCode;
6104}
6105extern "C" {
6106 pub fn PhidgetFirmwareUpgrade_sendFirmware(
6107 ch: PhidgetFirmwareUpgradeHandle,
6108 data: *const u8,
6109 dataLen: usize,
6110 ) -> PhidgetReturnCode;
6111}
6112extern "C" {
6113 pub fn PhidgetFirmwareUpgrade_getActualDeviceID(
6114 ch: PhidgetFirmwareUpgradeHandle,
6115 actualDeviceID: *mut Phidget_DeviceID,
6116 ) -> PhidgetReturnCode;
6117}
6118extern "C" {
6119 pub fn PhidgetFirmwareUpgrade_getActualDeviceName(
6120 ch: PhidgetFirmwareUpgradeHandle,
6121 actualDeviceName: *mut *const ::std::os::raw::c_char,
6122 ) -> PhidgetReturnCode;
6123}
6124extern "C" {
6125 pub fn PhidgetFirmwareUpgrade_getActualDeviceSKU(
6126 ch: PhidgetFirmwareUpgradeHandle,
6127 actualDeviceSKU: *mut *const ::std::os::raw::c_char,
6128 ) -> PhidgetReturnCode;
6129}
6130extern "C" {
6131 pub fn PhidgetFirmwareUpgrade_getActualDeviceVersion(
6132 ch: PhidgetFirmwareUpgradeHandle,
6133 actualDeviceVersion: *mut ::std::os::raw::c_int,
6134 ) -> PhidgetReturnCode;
6135}
6136extern "C" {
6137 pub fn PhidgetFirmwareUpgrade_getActualDeviceVINTID(
6138 ch: PhidgetFirmwareUpgradeHandle,
6139 actualDeviceVINTID: *mut u32,
6140 ) -> PhidgetReturnCode;
6141}
6142extern "C" {
6143 pub fn PhidgetFirmwareUpgrade_getProgress(
6144 ch: PhidgetFirmwareUpgradeHandle,
6145 progress: *mut f64,
6146 ) -> PhidgetReturnCode;
6147}
6148pub type PhidgetFirmwareUpgrade_OnProgressChangeCallback = ::std::option::Option<
6149 unsafe extern "C" fn(
6150 ch: PhidgetFirmwareUpgradeHandle,
6151 ctx: *mut ::std::os::raw::c_void,
6152 progress: f64,
6153 ),
6154>;
6155extern "C" {
6156 pub fn PhidgetFirmwareUpgrade_setOnProgressChangeHandler(
6157 ch: PhidgetFirmwareUpgradeHandle,
6158 fptr: PhidgetFirmwareUpgrade_OnProgressChangeCallback,
6159 ctx: *mut ::std::os::raw::c_void,
6160 ) -> PhidgetReturnCode;
6161}
6162#[repr(C)]
6163#[derive(Debug, Copy, Clone)]
6164pub struct _PhidgetFrequencyCounter {
6165 _unused: [u8; 0],
6166}
6167pub type PhidgetFrequencyCounterHandle = *mut _PhidgetFrequencyCounter;
6168extern "C" {
6169 pub fn PhidgetFrequencyCounter_create(
6170 ch: *mut PhidgetFrequencyCounterHandle,
6171 ) -> PhidgetReturnCode;
6172}
6173extern "C" {
6174 pub fn PhidgetFrequencyCounter_delete(
6175 ch: *mut PhidgetFrequencyCounterHandle,
6176 ) -> PhidgetReturnCode;
6177}
6178extern "C" {
6179 pub fn PhidgetFrequencyCounter_reset(ch: PhidgetFrequencyCounterHandle) -> PhidgetReturnCode;
6180}
6181extern "C" {
6182 pub fn PhidgetFrequencyCounter_getCount(
6183 ch: PhidgetFrequencyCounterHandle,
6184 count: *mut u64,
6185 ) -> PhidgetReturnCode;
6186}
6187extern "C" {
6188 pub fn PhidgetFrequencyCounter_setEnabled(
6189 ch: PhidgetFrequencyCounterHandle,
6190 enabled: ::std::os::raw::c_int,
6191 ) -> PhidgetReturnCode;
6192}
6193extern "C" {
6194 pub fn PhidgetFrequencyCounter_getEnabled(
6195 ch: PhidgetFrequencyCounterHandle,
6196 enabled: *mut ::std::os::raw::c_int,
6197 ) -> PhidgetReturnCode;
6198}
6199extern "C" {
6200 pub fn PhidgetFrequencyCounter_setDataInterval(
6201 ch: PhidgetFrequencyCounterHandle,
6202 dataInterval: u32,
6203 ) -> PhidgetReturnCode;
6204}
6205extern "C" {
6206 pub fn PhidgetFrequencyCounter_getDataInterval(
6207 ch: PhidgetFrequencyCounterHandle,
6208 dataInterval: *mut u32,
6209 ) -> PhidgetReturnCode;
6210}
6211extern "C" {
6212 pub fn PhidgetFrequencyCounter_getMinDataInterval(
6213 ch: PhidgetFrequencyCounterHandle,
6214 minDataInterval: *mut u32,
6215 ) -> PhidgetReturnCode;
6216}
6217extern "C" {
6218 pub fn PhidgetFrequencyCounter_getMaxDataInterval(
6219 ch: PhidgetFrequencyCounterHandle,
6220 maxDataInterval: *mut u32,
6221 ) -> PhidgetReturnCode;
6222}
6223extern "C" {
6224 pub fn PhidgetFrequencyCounter_setDataRate(
6225 ch: PhidgetFrequencyCounterHandle,
6226 dataRate: f64,
6227 ) -> PhidgetReturnCode;
6228}
6229extern "C" {
6230 pub fn PhidgetFrequencyCounter_getDataRate(
6231 ch: PhidgetFrequencyCounterHandle,
6232 dataRate: *mut f64,
6233 ) -> PhidgetReturnCode;
6234}
6235extern "C" {
6236 pub fn PhidgetFrequencyCounter_getMinDataRate(
6237 ch: PhidgetFrequencyCounterHandle,
6238 minDataRate: *mut f64,
6239 ) -> PhidgetReturnCode;
6240}
6241extern "C" {
6242 pub fn PhidgetFrequencyCounter_getMaxDataRate(
6243 ch: PhidgetFrequencyCounterHandle,
6244 maxDataRate: *mut f64,
6245 ) -> PhidgetReturnCode;
6246}
6247extern "C" {
6248 pub fn PhidgetFrequencyCounter_setFilterType(
6249 ch: PhidgetFrequencyCounterHandle,
6250 filterType: PhidgetFrequencyCounter_FilterType,
6251 ) -> PhidgetReturnCode;
6252}
6253extern "C" {
6254 pub fn PhidgetFrequencyCounter_getFilterType(
6255 ch: PhidgetFrequencyCounterHandle,
6256 filterType: *mut PhidgetFrequencyCounter_FilterType,
6257 ) -> PhidgetReturnCode;
6258}
6259extern "C" {
6260 pub fn PhidgetFrequencyCounter_getFrequency(
6261 ch: PhidgetFrequencyCounterHandle,
6262 frequency: *mut f64,
6263 ) -> PhidgetReturnCode;
6264}
6265extern "C" {
6266 pub fn PhidgetFrequencyCounter_getMaxFrequency(
6267 ch: PhidgetFrequencyCounterHandle,
6268 maxFrequency: *mut f64,
6269 ) -> PhidgetReturnCode;
6270}
6271extern "C" {
6272 pub fn PhidgetFrequencyCounter_setFrequencyCutoff(
6273 ch: PhidgetFrequencyCounterHandle,
6274 frequencyCutoff: f64,
6275 ) -> PhidgetReturnCode;
6276}
6277extern "C" {
6278 pub fn PhidgetFrequencyCounter_getFrequencyCutoff(
6279 ch: PhidgetFrequencyCounterHandle,
6280 frequencyCutoff: *mut f64,
6281 ) -> PhidgetReturnCode;
6282}
6283extern "C" {
6284 pub fn PhidgetFrequencyCounter_getMinFrequencyCutoff(
6285 ch: PhidgetFrequencyCounterHandle,
6286 minFrequencyCutoff: *mut f64,
6287 ) -> PhidgetReturnCode;
6288}
6289extern "C" {
6290 pub fn PhidgetFrequencyCounter_getMaxFrequencyCutoff(
6291 ch: PhidgetFrequencyCounterHandle,
6292 maxFrequencyCutoff: *mut f64,
6293 ) -> PhidgetReturnCode;
6294}
6295extern "C" {
6296 pub fn PhidgetFrequencyCounter_setInputMode(
6297 ch: PhidgetFrequencyCounterHandle,
6298 inputMode: Phidget_InputMode,
6299 ) -> PhidgetReturnCode;
6300}
6301extern "C" {
6302 pub fn PhidgetFrequencyCounter_getInputMode(
6303 ch: PhidgetFrequencyCounterHandle,
6304 inputMode: *mut Phidget_InputMode,
6305 ) -> PhidgetReturnCode;
6306}
6307extern "C" {
6308 pub fn PhidgetFrequencyCounter_setPowerSupply(
6309 ch: PhidgetFrequencyCounterHandle,
6310 powerSupply: Phidget_PowerSupply,
6311 ) -> PhidgetReturnCode;
6312}
6313extern "C" {
6314 pub fn PhidgetFrequencyCounter_getPowerSupply(
6315 ch: PhidgetFrequencyCounterHandle,
6316 powerSupply: *mut Phidget_PowerSupply,
6317 ) -> PhidgetReturnCode;
6318}
6319extern "C" {
6320 pub fn PhidgetFrequencyCounter_getTimeElapsed(
6321 ch: PhidgetFrequencyCounterHandle,
6322 timeElapsed: *mut f64,
6323 ) -> PhidgetReturnCode;
6324}
6325pub type PhidgetFrequencyCounter_OnCountChangeCallback = ::std::option::Option<
6326 unsafe extern "C" fn(
6327 ch: PhidgetFrequencyCounterHandle,
6328 ctx: *mut ::std::os::raw::c_void,
6329 counts: u64,
6330 timeChange: f64,
6331 ),
6332>;
6333extern "C" {
6334 pub fn PhidgetFrequencyCounter_setOnCountChangeHandler(
6335 ch: PhidgetFrequencyCounterHandle,
6336 fptr: PhidgetFrequencyCounter_OnCountChangeCallback,
6337 ctx: *mut ::std::os::raw::c_void,
6338 ) -> PhidgetReturnCode;
6339}
6340pub type PhidgetFrequencyCounter_OnFrequencyChangeCallback = ::std::option::Option<
6341 unsafe extern "C" fn(
6342 ch: PhidgetFrequencyCounterHandle,
6343 ctx: *mut ::std::os::raw::c_void,
6344 frequency: f64,
6345 ),
6346>;
6347extern "C" {
6348 pub fn PhidgetFrequencyCounter_setOnFrequencyChangeHandler(
6349 ch: PhidgetFrequencyCounterHandle,
6350 fptr: PhidgetFrequencyCounter_OnFrequencyChangeCallback,
6351 ctx: *mut ::std::os::raw::c_void,
6352 ) -> PhidgetReturnCode;
6353}
6354#[repr(C)]
6355#[derive(Debug, Copy, Clone)]
6356pub struct _PhidgetGPS {
6357 _unused: [u8; 0],
6358}
6359pub type PhidgetGPSHandle = *mut _PhidgetGPS;
6360extern "C" {
6361 pub fn PhidgetGPS_create(ch: *mut PhidgetGPSHandle) -> PhidgetReturnCode;
6362}
6363extern "C" {
6364 pub fn PhidgetGPS_delete(ch: *mut PhidgetGPSHandle) -> PhidgetReturnCode;
6365}
6366extern "C" {
6367 pub fn PhidgetGPS_getAltitude(ch: PhidgetGPSHandle, altitude: *mut f64) -> PhidgetReturnCode;
6368}
6369extern "C" {
6370 pub fn PhidgetGPS_getDate(
6371 ch: PhidgetGPSHandle,
6372 date: *mut PhidgetGPS_Date,
6373 ) -> PhidgetReturnCode;
6374}
6375extern "C" {
6376 pub fn PhidgetGPS_getHeading(ch: PhidgetGPSHandle, heading: *mut f64) -> PhidgetReturnCode;
6377}
6378extern "C" {
6379 pub fn PhidgetGPS_getLatitude(ch: PhidgetGPSHandle, latitude: *mut f64) -> PhidgetReturnCode;
6380}
6381extern "C" {
6382 pub fn PhidgetGPS_getLongitude(ch: PhidgetGPSHandle, longitude: *mut f64) -> PhidgetReturnCode;
6383}
6384extern "C" {
6385 pub fn PhidgetGPS_getNMEAData(
6386 ch: PhidgetGPSHandle,
6387 NMEAData: *mut PhidgetGPS_NMEAData,
6388 ) -> PhidgetReturnCode;
6389}
6390extern "C" {
6391 pub fn PhidgetGPS_getPositionFixState(
6392 ch: PhidgetGPSHandle,
6393 positionFixState: *mut ::std::os::raw::c_int,
6394 ) -> PhidgetReturnCode;
6395}
6396extern "C" {
6397 pub fn PhidgetGPS_getTime(
6398 ch: PhidgetGPSHandle,
6399 time: *mut PhidgetGPS_Time,
6400 ) -> PhidgetReturnCode;
6401}
6402extern "C" {
6403 pub fn PhidgetGPS_getVelocity(ch: PhidgetGPSHandle, velocity: *mut f64) -> PhidgetReturnCode;
6404}
6405pub type PhidgetGPS_OnHeadingChangeCallback = ::std::option::Option<
6406 unsafe extern "C" fn(
6407 ch: PhidgetGPSHandle,
6408 ctx: *mut ::std::os::raw::c_void,
6409 heading: f64,
6410 velocity: f64,
6411 ),
6412>;
6413extern "C" {
6414 pub fn PhidgetGPS_setOnHeadingChangeHandler(
6415 ch: PhidgetGPSHandle,
6416 fptr: PhidgetGPS_OnHeadingChangeCallback,
6417 ctx: *mut ::std::os::raw::c_void,
6418 ) -> PhidgetReturnCode;
6419}
6420pub type PhidgetGPS_OnPositionChangeCallback = ::std::option::Option<
6421 unsafe extern "C" fn(
6422 ch: PhidgetGPSHandle,
6423 ctx: *mut ::std::os::raw::c_void,
6424 latitude: f64,
6425 longitude: f64,
6426 altitude: f64,
6427 ),
6428>;
6429extern "C" {
6430 pub fn PhidgetGPS_setOnPositionChangeHandler(
6431 ch: PhidgetGPSHandle,
6432 fptr: PhidgetGPS_OnPositionChangeCallback,
6433 ctx: *mut ::std::os::raw::c_void,
6434 ) -> PhidgetReturnCode;
6435}
6436pub type PhidgetGPS_OnPositionFixStateChangeCallback = ::std::option::Option<
6437 unsafe extern "C" fn(
6438 ch: PhidgetGPSHandle,
6439 ctx: *mut ::std::os::raw::c_void,
6440 positionFixState: ::std::os::raw::c_int,
6441 ),
6442>;
6443extern "C" {
6444 pub fn PhidgetGPS_setOnPositionFixStateChangeHandler(
6445 ch: PhidgetGPSHandle,
6446 fptr: PhidgetGPS_OnPositionFixStateChangeCallback,
6447 ctx: *mut ::std::os::raw::c_void,
6448 ) -> PhidgetReturnCode;
6449}
6450#[repr(C)]
6451#[derive(Debug, Copy, Clone)]
6452pub struct _PhidgetGeneric {
6453 _unused: [u8; 0],
6454}
6455pub type PhidgetGenericHandle = *mut _PhidgetGeneric;
6456extern "C" {
6457 pub fn PhidgetGeneric_create(ch: *mut PhidgetGenericHandle) -> PhidgetReturnCode;
6458}
6459extern "C" {
6460 pub fn PhidgetGeneric_delete(ch: *mut PhidgetGenericHandle) -> PhidgetReturnCode;
6461}
6462#[repr(C)]
6463#[derive(Debug, Copy, Clone)]
6464pub struct _PhidgetGyroscope {
6465 _unused: [u8; 0],
6466}
6467pub type PhidgetGyroscopeHandle = *mut _PhidgetGyroscope;
6468extern "C" {
6469 pub fn PhidgetGyroscope_create(ch: *mut PhidgetGyroscopeHandle) -> PhidgetReturnCode;
6470}
6471extern "C" {
6472 pub fn PhidgetGyroscope_delete(ch: *mut PhidgetGyroscopeHandle) -> PhidgetReturnCode;
6473}
6474extern "C" {
6475 pub fn PhidgetGyroscope_zero(ch: PhidgetGyroscopeHandle) -> PhidgetReturnCode;
6476}
6477extern "C" {
6478 pub fn PhidgetGyroscope_getAngularRate(
6479 ch: PhidgetGyroscopeHandle,
6480 angularRate: *mut [f64; 3usize],
6481 ) -> PhidgetReturnCode;
6482}
6483extern "C" {
6484 pub fn PhidgetGyroscope_getMinAngularRate(
6485 ch: PhidgetGyroscopeHandle,
6486 minAngularRate: *mut [f64; 3usize],
6487 ) -> PhidgetReturnCode;
6488}
6489extern "C" {
6490 pub fn PhidgetGyroscope_getMaxAngularRate(
6491 ch: PhidgetGyroscopeHandle,
6492 maxAngularRate: *mut [f64; 3usize],
6493 ) -> PhidgetReturnCode;
6494}
6495extern "C" {
6496 pub fn PhidgetGyroscope_getAxisCount(
6497 ch: PhidgetGyroscopeHandle,
6498 axisCount: *mut ::std::os::raw::c_int,
6499 ) -> PhidgetReturnCode;
6500}
6501extern "C" {
6502 pub fn PhidgetGyroscope_setDataInterval(
6503 ch: PhidgetGyroscopeHandle,
6504 dataInterval: u32,
6505 ) -> PhidgetReturnCode;
6506}
6507extern "C" {
6508 pub fn PhidgetGyroscope_getDataInterval(
6509 ch: PhidgetGyroscopeHandle,
6510 dataInterval: *mut u32,
6511 ) -> PhidgetReturnCode;
6512}
6513extern "C" {
6514 pub fn PhidgetGyroscope_getMinDataInterval(
6515 ch: PhidgetGyroscopeHandle,
6516 minDataInterval: *mut u32,
6517 ) -> PhidgetReturnCode;
6518}
6519extern "C" {
6520 pub fn PhidgetGyroscope_getMaxDataInterval(
6521 ch: PhidgetGyroscopeHandle,
6522 maxDataInterval: *mut u32,
6523 ) -> PhidgetReturnCode;
6524}
6525extern "C" {
6526 pub fn PhidgetGyroscope_setDataRate(
6527 ch: PhidgetGyroscopeHandle,
6528 dataRate: f64,
6529 ) -> PhidgetReturnCode;
6530}
6531extern "C" {
6532 pub fn PhidgetGyroscope_getDataRate(
6533 ch: PhidgetGyroscopeHandle,
6534 dataRate: *mut f64,
6535 ) -> PhidgetReturnCode;
6536}
6537extern "C" {
6538 pub fn PhidgetGyroscope_getMinDataRate(
6539 ch: PhidgetGyroscopeHandle,
6540 minDataRate: *mut f64,
6541 ) -> PhidgetReturnCode;
6542}
6543extern "C" {
6544 pub fn PhidgetGyroscope_getMaxDataRate(
6545 ch: PhidgetGyroscopeHandle,
6546 maxDataRate: *mut f64,
6547 ) -> PhidgetReturnCode;
6548}
6549extern "C" {
6550 pub fn PhidgetGyroscope_setHeatingEnabled(
6551 ch: PhidgetGyroscopeHandle,
6552 heatingEnabled: ::std::os::raw::c_int,
6553 ) -> PhidgetReturnCode;
6554}
6555extern "C" {
6556 pub fn PhidgetGyroscope_getHeatingEnabled(
6557 ch: PhidgetGyroscopeHandle,
6558 heatingEnabled: *mut ::std::os::raw::c_int,
6559 ) -> PhidgetReturnCode;
6560}
6561extern "C" {
6562 pub fn PhidgetGyroscope_setPrecision(
6563 ch: PhidgetGyroscopeHandle,
6564 precision: Phidget_SpatialPrecision,
6565 ) -> PhidgetReturnCode;
6566}
6567extern "C" {
6568 pub fn PhidgetGyroscope_getPrecision(
6569 ch: PhidgetGyroscopeHandle,
6570 precision: *mut Phidget_SpatialPrecision,
6571 ) -> PhidgetReturnCode;
6572}
6573extern "C" {
6574 pub fn PhidgetGyroscope_getTimestamp(
6575 ch: PhidgetGyroscopeHandle,
6576 timestamp: *mut f64,
6577 ) -> PhidgetReturnCode;
6578}
6579pub type PhidgetGyroscope_OnAngularRateUpdateCallback = ::std::option::Option<
6580 unsafe extern "C" fn(
6581 ch: PhidgetGyroscopeHandle,
6582 ctx: *mut ::std::os::raw::c_void,
6583 angularRate: *const f64,
6584 timestamp: f64,
6585 ),
6586>;
6587extern "C" {
6588 pub fn PhidgetGyroscope_setOnAngularRateUpdateHandler(
6589 ch: PhidgetGyroscopeHandle,
6590 fptr: PhidgetGyroscope_OnAngularRateUpdateCallback,
6591 ctx: *mut ::std::os::raw::c_void,
6592 ) -> PhidgetReturnCode;
6593}
6594#[repr(C)]
6595#[derive(Debug, Copy, Clone)]
6596pub struct _PhidgetHub {
6597 _unused: [u8; 0],
6598}
6599pub type PhidgetHubHandle = *mut _PhidgetHub;
6600extern "C" {
6601 pub fn PhidgetHub_create(ch: *mut PhidgetHubHandle) -> PhidgetReturnCode;
6602}
6603extern "C" {
6604 pub fn PhidgetHub_delete(ch: *mut PhidgetHubHandle) -> PhidgetReturnCode;
6605}
6606extern "C" {
6607 pub fn PhidgetHub_setADCCalibrationValues(
6608 ch: PhidgetHubHandle,
6609 voltageInputGain: *mut f64,
6610 voltageRatioGain: *mut f64,
6611 ) -> PhidgetReturnCode;
6612}
6613extern "C" {
6614 pub fn PhidgetHub_setADCCalibrationValues2(
6615 ch: PhidgetHubHandle,
6616 voltageInputOffset: *const f64,
6617 voltageInputOffsetLen: usize,
6618 voltageInputGain: *const f64,
6619 voltageInputGainLen: usize,
6620 voltageRatioOffset: *const f64,
6621 voltageRatioOffsetLen: usize,
6622 voltageRatioGain: *const f64,
6623 voltageRatioGainLen: usize,
6624 ) -> PhidgetReturnCode;
6625}
6626extern "C" {
6627 pub fn PhidgetHub_setFirmwareUpgradeFlag(
6628 ch: PhidgetHubHandle,
6629 port: ::std::os::raw::c_int,
6630 timeout: u32,
6631 ) -> PhidgetReturnCode;
6632}
6633extern "C" {
6634 pub fn PhidgetHub_setPortAutoSetSpeed(
6635 ch: PhidgetHubHandle,
6636 port: ::std::os::raw::c_int,
6637 state: ::std::os::raw::c_int,
6638 ) -> PhidgetReturnCode;
6639}
6640extern "C" {
6641 pub fn PhidgetHub_getPortMaxSpeed(
6642 ch: PhidgetHubHandle,
6643 port: ::std::os::raw::c_int,
6644 state: *mut u32,
6645 ) -> PhidgetReturnCode;
6646}
6647extern "C" {
6648 pub fn PhidgetHub_getPortMode(
6649 ch: PhidgetHubHandle,
6650 port: ::std::os::raw::c_int,
6651 mode: *mut PhidgetHub_PortMode,
6652 ) -> PhidgetReturnCode;
6653}
6654extern "C" {
6655 pub fn PhidgetHub_setPortMode(
6656 ch: PhidgetHubHandle,
6657 port: ::std::os::raw::c_int,
6658 mode: PhidgetHub_PortMode,
6659 ) -> PhidgetReturnCode;
6660}
6661extern "C" {
6662 pub fn PhidgetHub_getPortPower(
6663 ch: PhidgetHubHandle,
6664 port: ::std::os::raw::c_int,
6665 state: *mut ::std::os::raw::c_int,
6666 ) -> PhidgetReturnCode;
6667}
6668extern "C" {
6669 pub fn PhidgetHub_setPortPower(
6670 ch: PhidgetHubHandle,
6671 port: ::std::os::raw::c_int,
6672 state: ::std::os::raw::c_int,
6673 ) -> PhidgetReturnCode;
6674}
6675extern "C" {
6676 pub fn PhidgetHub_getPortSupportsAutoSetSpeed(
6677 ch: PhidgetHubHandle,
6678 port: ::std::os::raw::c_int,
6679 state: *mut ::std::os::raw::c_int,
6680 ) -> PhidgetReturnCode;
6681}
6682extern "C" {
6683 pub fn PhidgetHub_getPortSupportsSetSpeed(
6684 ch: PhidgetHubHandle,
6685 port: ::std::os::raw::c_int,
6686 state: *mut ::std::os::raw::c_int,
6687 ) -> PhidgetReturnCode;
6688}
6689#[repr(C)]
6690#[derive(Debug, Copy, Clone)]
6691pub struct _PhidgetHumiditySensor {
6692 _unused: [u8; 0],
6693}
6694pub type PhidgetHumiditySensorHandle = *mut _PhidgetHumiditySensor;
6695extern "C" {
6696 pub fn PhidgetHumiditySensor_create(ch: *mut PhidgetHumiditySensorHandle) -> PhidgetReturnCode;
6697}
6698extern "C" {
6699 pub fn PhidgetHumiditySensor_delete(ch: *mut PhidgetHumiditySensorHandle) -> PhidgetReturnCode;
6700}
6701extern "C" {
6702 pub fn PhidgetHumiditySensor_setDataInterval(
6703 ch: PhidgetHumiditySensorHandle,
6704 dataInterval: u32,
6705 ) -> PhidgetReturnCode;
6706}
6707extern "C" {
6708 pub fn PhidgetHumiditySensor_getDataInterval(
6709 ch: PhidgetHumiditySensorHandle,
6710 dataInterval: *mut u32,
6711 ) -> PhidgetReturnCode;
6712}
6713extern "C" {
6714 pub fn PhidgetHumiditySensor_getMinDataInterval(
6715 ch: PhidgetHumiditySensorHandle,
6716 minDataInterval: *mut u32,
6717 ) -> PhidgetReturnCode;
6718}
6719extern "C" {
6720 pub fn PhidgetHumiditySensor_getMaxDataInterval(
6721 ch: PhidgetHumiditySensorHandle,
6722 maxDataInterval: *mut u32,
6723 ) -> PhidgetReturnCode;
6724}
6725extern "C" {
6726 pub fn PhidgetHumiditySensor_setDataRate(
6727 ch: PhidgetHumiditySensorHandle,
6728 dataRate: f64,
6729 ) -> PhidgetReturnCode;
6730}
6731extern "C" {
6732 pub fn PhidgetHumiditySensor_getDataRate(
6733 ch: PhidgetHumiditySensorHandle,
6734 dataRate: *mut f64,
6735 ) -> PhidgetReturnCode;
6736}
6737extern "C" {
6738 pub fn PhidgetHumiditySensor_getMinDataRate(
6739 ch: PhidgetHumiditySensorHandle,
6740 minDataRate: *mut f64,
6741 ) -> PhidgetReturnCode;
6742}
6743extern "C" {
6744 pub fn PhidgetHumiditySensor_getMaxDataRate(
6745 ch: PhidgetHumiditySensorHandle,
6746 maxDataRate: *mut f64,
6747 ) -> PhidgetReturnCode;
6748}
6749extern "C" {
6750 pub fn PhidgetHumiditySensor_getHumidity(
6751 ch: PhidgetHumiditySensorHandle,
6752 humidity: *mut f64,
6753 ) -> PhidgetReturnCode;
6754}
6755extern "C" {
6756 pub fn PhidgetHumiditySensor_getMinHumidity(
6757 ch: PhidgetHumiditySensorHandle,
6758 minHumidity: *mut f64,
6759 ) -> PhidgetReturnCode;
6760}
6761extern "C" {
6762 pub fn PhidgetHumiditySensor_getMaxHumidity(
6763 ch: PhidgetHumiditySensorHandle,
6764 maxHumidity: *mut f64,
6765 ) -> PhidgetReturnCode;
6766}
6767extern "C" {
6768 pub fn PhidgetHumiditySensor_setHumidityChangeTrigger(
6769 ch: PhidgetHumiditySensorHandle,
6770 humidityChangeTrigger: f64,
6771 ) -> PhidgetReturnCode;
6772}
6773extern "C" {
6774 pub fn PhidgetHumiditySensor_getHumidityChangeTrigger(
6775 ch: PhidgetHumiditySensorHandle,
6776 humidityChangeTrigger: *mut f64,
6777 ) -> PhidgetReturnCode;
6778}
6779extern "C" {
6780 pub fn PhidgetHumiditySensor_getMinHumidityChangeTrigger(
6781 ch: PhidgetHumiditySensorHandle,
6782 minHumidityChangeTrigger: *mut f64,
6783 ) -> PhidgetReturnCode;
6784}
6785extern "C" {
6786 pub fn PhidgetHumiditySensor_getMaxHumidityChangeTrigger(
6787 ch: PhidgetHumiditySensorHandle,
6788 maxHumidityChangeTrigger: *mut f64,
6789 ) -> PhidgetReturnCode;
6790}
6791pub type PhidgetHumiditySensor_OnHumidityChangeCallback = ::std::option::Option<
6792 unsafe extern "C" fn(
6793 ch: PhidgetHumiditySensorHandle,
6794 ctx: *mut ::std::os::raw::c_void,
6795 humidity: f64,
6796 ),
6797>;
6798extern "C" {
6799 pub fn PhidgetHumiditySensor_setOnHumidityChangeHandler(
6800 ch: PhidgetHumiditySensorHandle,
6801 fptr: PhidgetHumiditySensor_OnHumidityChangeCallback,
6802 ctx: *mut ::std::os::raw::c_void,
6803 ) -> PhidgetReturnCode;
6804}
6805#[repr(C)]
6806#[derive(Debug, Copy, Clone)]
6807pub struct _PhidgetIR {
6808 _unused: [u8; 0],
6809}
6810pub type PhidgetIRHandle = *mut _PhidgetIR;
6811extern "C" {
6812 pub fn PhidgetIR_create(ch: *mut PhidgetIRHandle) -> PhidgetReturnCode;
6813}
6814extern "C" {
6815 pub fn PhidgetIR_delete(ch: *mut PhidgetIRHandle) -> PhidgetReturnCode;
6816}
6817extern "C" {
6818 pub fn PhidgetIR_getLastCode(
6819 ch: PhidgetIRHandle,
6820 code: *mut ::std::os::raw::c_char,
6821 codeLen: usize,
6822 bitCount: *mut u32,
6823 ) -> PhidgetReturnCode;
6824}
6825extern "C" {
6826 pub fn PhidgetIR_getLastLearnedCode(
6827 ch: PhidgetIRHandle,
6828 code: *mut ::std::os::raw::c_char,
6829 codeLen: usize,
6830 codeInfo: *mut PhidgetIR_CodeInfo,
6831 ) -> PhidgetReturnCode;
6832}
6833extern "C" {
6834 pub fn PhidgetIR_transmit(
6835 ch: PhidgetIRHandle,
6836 code: *const ::std::os::raw::c_char,
6837 codeInfo: *mut PhidgetIR_CodeInfo,
6838 ) -> PhidgetReturnCode;
6839}
6840extern "C" {
6841 pub fn PhidgetIR_transmitRaw(
6842 ch: PhidgetIRHandle,
6843 data: *const u32,
6844 dataLen: usize,
6845 carrierFrequency: u32,
6846 dutyCycle: f64,
6847 gap: u32,
6848 ) -> PhidgetReturnCode;
6849}
6850extern "C" {
6851 pub fn PhidgetIR_transmitRepeat(ch: PhidgetIRHandle) -> PhidgetReturnCode;
6852}
6853pub type PhidgetIR_OnCodeCallback = ::std::option::Option<
6854 unsafe extern "C" fn(
6855 ch: PhidgetIRHandle,
6856 ctx: *mut ::std::os::raw::c_void,
6857 code: *const ::std::os::raw::c_char,
6858 bitCount: u32,
6859 isRepeat: ::std::os::raw::c_int,
6860 ),
6861>;
6862extern "C" {
6863 pub fn PhidgetIR_setOnCodeHandler(
6864 ch: PhidgetIRHandle,
6865 fptr: PhidgetIR_OnCodeCallback,
6866 ctx: *mut ::std::os::raw::c_void,
6867 ) -> PhidgetReturnCode;
6868}
6869pub type PhidgetIR_OnLearnCallback = ::std::option::Option<
6870 unsafe extern "C" fn(
6871 ch: PhidgetIRHandle,
6872 ctx: *mut ::std::os::raw::c_void,
6873 code: *const ::std::os::raw::c_char,
6874 codeInfo: *mut PhidgetIR_CodeInfo,
6875 ),
6876>;
6877extern "C" {
6878 pub fn PhidgetIR_setOnLearnHandler(
6879 ch: PhidgetIRHandle,
6880 fptr: PhidgetIR_OnLearnCallback,
6881 ctx: *mut ::std::os::raw::c_void,
6882 ) -> PhidgetReturnCode;
6883}
6884pub type PhidgetIR_OnRawDataCallback = ::std::option::Option<
6885 unsafe extern "C" fn(
6886 ch: PhidgetIRHandle,
6887 ctx: *mut ::std::os::raw::c_void,
6888 data: *const u32,
6889 dataLen: usize,
6890 ),
6891>;
6892extern "C" {
6893 pub fn PhidgetIR_setOnRawDataHandler(
6894 ch: PhidgetIRHandle,
6895 fptr: PhidgetIR_OnRawDataCallback,
6896 ctx: *mut ::std::os::raw::c_void,
6897 ) -> PhidgetReturnCode;
6898}
6899#[repr(C)]
6900#[derive(Debug, Copy, Clone)]
6901pub struct _PhidgetLCD {
6902 _unused: [u8; 0],
6903}
6904pub type PhidgetLCDHandle = *mut _PhidgetLCD;
6905extern "C" {
6906 pub fn PhidgetLCD_create(ch: *mut PhidgetLCDHandle) -> PhidgetReturnCode;
6907}
6908extern "C" {
6909 pub fn PhidgetLCD_delete(ch: *mut PhidgetLCDHandle) -> PhidgetReturnCode;
6910}
6911extern "C" {
6912 pub fn PhidgetLCD_setCharacterBitmap(
6913 ch: PhidgetLCDHandle,
6914 font: PhidgetLCD_Font,
6915 character: *const ::std::os::raw::c_char,
6916 bitmap: *const u8,
6917 ) -> PhidgetReturnCode;
6918}
6919extern "C" {
6920 pub fn PhidgetLCD_setCharacterBitmap_async(
6921 ch: PhidgetLCDHandle,
6922 font: PhidgetLCD_Font,
6923 character: *const ::std::os::raw::c_char,
6924 bitmap: *const u8,
6925 fptr: Phidget_AsyncCallback,
6926 ctx: *mut ::std::os::raw::c_void,
6927 );
6928}
6929extern "C" {
6930 pub fn PhidgetLCD_getMaxCharacters(
6931 ch: PhidgetLCDHandle,
6932 font: PhidgetLCD_Font,
6933 maxCharacters: *mut ::std::os::raw::c_int,
6934 ) -> PhidgetReturnCode;
6935}
6936extern "C" {
6937 pub fn PhidgetLCD_clear(ch: PhidgetLCDHandle) -> PhidgetReturnCode;
6938}
6939extern "C" {
6940 pub fn PhidgetLCD_clear_async(
6941 ch: PhidgetLCDHandle,
6942 fptr: Phidget_AsyncCallback,
6943 ctx: *mut ::std::os::raw::c_void,
6944 );
6945}
6946extern "C" {
6947 pub fn PhidgetLCD_copy(
6948 ch: PhidgetLCDHandle,
6949 sourceFramebuffer: ::std::os::raw::c_int,
6950 destFramebuffer: ::std::os::raw::c_int,
6951 sourceX1: ::std::os::raw::c_int,
6952 sourceY1: ::std::os::raw::c_int,
6953 sourceX2: ::std::os::raw::c_int,
6954 sourceY2: ::std::os::raw::c_int,
6955 destX: ::std::os::raw::c_int,
6956 destY: ::std::os::raw::c_int,
6957 inverted: ::std::os::raw::c_int,
6958 ) -> PhidgetReturnCode;
6959}
6960extern "C" {
6961 pub fn PhidgetLCD_copy_async(
6962 ch: PhidgetLCDHandle,
6963 sourceFramebuffer: ::std::os::raw::c_int,
6964 destFramebuffer: ::std::os::raw::c_int,
6965 sourceX1: ::std::os::raw::c_int,
6966 sourceY1: ::std::os::raw::c_int,
6967 sourceX2: ::std::os::raw::c_int,
6968 sourceY2: ::std::os::raw::c_int,
6969 destX: ::std::os::raw::c_int,
6970 destY: ::std::os::raw::c_int,
6971 inverted: ::std::os::raw::c_int,
6972 fptr: Phidget_AsyncCallback,
6973 ctx: *mut ::std::os::raw::c_void,
6974 );
6975}
6976extern "C" {
6977 pub fn PhidgetLCD_drawLine(
6978 ch: PhidgetLCDHandle,
6979 x1: ::std::os::raw::c_int,
6980 y1: ::std::os::raw::c_int,
6981 x2: ::std::os::raw::c_int,
6982 y2: ::std::os::raw::c_int,
6983 ) -> PhidgetReturnCode;
6984}
6985extern "C" {
6986 pub fn PhidgetLCD_drawLine_async(
6987 ch: PhidgetLCDHandle,
6988 x1: ::std::os::raw::c_int,
6989 y1: ::std::os::raw::c_int,
6990 x2: ::std::os::raw::c_int,
6991 y2: ::std::os::raw::c_int,
6992 fptr: Phidget_AsyncCallback,
6993 ctx: *mut ::std::os::raw::c_void,
6994 );
6995}
6996extern "C" {
6997 pub fn PhidgetLCD_drawPixel(
6998 ch: PhidgetLCDHandle,
6999 x: ::std::os::raw::c_int,
7000 y: ::std::os::raw::c_int,
7001 pixelState: PhidgetLCD_PixelState,
7002 ) -> PhidgetReturnCode;
7003}
7004extern "C" {
7005 pub fn PhidgetLCD_drawPixel_async(
7006 ch: PhidgetLCDHandle,
7007 x: ::std::os::raw::c_int,
7008 y: ::std::os::raw::c_int,
7009 pixelState: PhidgetLCD_PixelState,
7010 fptr: Phidget_AsyncCallback,
7011 ctx: *mut ::std::os::raw::c_void,
7012 );
7013}
7014extern "C" {
7015 pub fn PhidgetLCD_drawRect(
7016 ch: PhidgetLCDHandle,
7017 x1: ::std::os::raw::c_int,
7018 y1: ::std::os::raw::c_int,
7019 x2: ::std::os::raw::c_int,
7020 y2: ::std::os::raw::c_int,
7021 filled: ::std::os::raw::c_int,
7022 inverted: ::std::os::raw::c_int,
7023 ) -> PhidgetReturnCode;
7024}
7025extern "C" {
7026 pub fn PhidgetLCD_drawRect_async(
7027 ch: PhidgetLCDHandle,
7028 x1: ::std::os::raw::c_int,
7029 y1: ::std::os::raw::c_int,
7030 x2: ::std::os::raw::c_int,
7031 y2: ::std::os::raw::c_int,
7032 filled: ::std::os::raw::c_int,
7033 inverted: ::std::os::raw::c_int,
7034 fptr: Phidget_AsyncCallback,
7035 ctx: *mut ::std::os::raw::c_void,
7036 );
7037}
7038extern "C" {
7039 pub fn PhidgetLCD_flush(ch: PhidgetLCDHandle) -> PhidgetReturnCode;
7040}
7041extern "C" {
7042 pub fn PhidgetLCD_flush_async(
7043 ch: PhidgetLCDHandle,
7044 fptr: Phidget_AsyncCallback,
7045 ctx: *mut ::std::os::raw::c_void,
7046 );
7047}
7048extern "C" {
7049 pub fn PhidgetLCD_getFontSize(
7050 ch: PhidgetLCDHandle,
7051 font: PhidgetLCD_Font,
7052 width: *mut ::std::os::raw::c_int,
7053 height: *mut ::std::os::raw::c_int,
7054 ) -> PhidgetReturnCode;
7055}
7056extern "C" {
7057 pub fn PhidgetLCD_setFontSize(
7058 ch: PhidgetLCDHandle,
7059 font: PhidgetLCD_Font,
7060 width: ::std::os::raw::c_int,
7061 height: ::std::os::raw::c_int,
7062 ) -> PhidgetReturnCode;
7063}
7064extern "C" {
7065 pub fn PhidgetLCD_initialize(ch: PhidgetLCDHandle) -> PhidgetReturnCode;
7066}
7067extern "C" {
7068 pub fn PhidgetLCD_saveFrameBuffer(
7069 ch: PhidgetLCDHandle,
7070 frameBuffer: ::std::os::raw::c_int,
7071 ) -> PhidgetReturnCode;
7072}
7073extern "C" {
7074 pub fn PhidgetLCD_saveFrameBuffer_async(
7075 ch: PhidgetLCDHandle,
7076 frameBuffer: ::std::os::raw::c_int,
7077 fptr: Phidget_AsyncCallback,
7078 ctx: *mut ::std::os::raw::c_void,
7079 );
7080}
7081extern "C" {
7082 pub fn PhidgetLCD_writeBitmap(
7083 ch: PhidgetLCDHandle,
7084 xPosition: ::std::os::raw::c_int,
7085 yPosition: ::std::os::raw::c_int,
7086 xSize: ::std::os::raw::c_int,
7087 ySize: ::std::os::raw::c_int,
7088 bitmap: *const u8,
7089 ) -> PhidgetReturnCode;
7090}
7091extern "C" {
7092 pub fn PhidgetLCD_writeBitmap_async(
7093 ch: PhidgetLCDHandle,
7094 xPosition: ::std::os::raw::c_int,
7095 yPosition: ::std::os::raw::c_int,
7096 xSize: ::std::os::raw::c_int,
7097 ySize: ::std::os::raw::c_int,
7098 bitmap: *const u8,
7099 fptr: Phidget_AsyncCallback,
7100 ctx: *mut ::std::os::raw::c_void,
7101 );
7102}
7103extern "C" {
7104 pub fn PhidgetLCD_writeText(
7105 ch: PhidgetLCDHandle,
7106 font: PhidgetLCD_Font,
7107 xPosition: ::std::os::raw::c_int,
7108 yPosition: ::std::os::raw::c_int,
7109 text: *const ::std::os::raw::c_char,
7110 ) -> PhidgetReturnCode;
7111}
7112extern "C" {
7113 pub fn PhidgetLCD_writeText_async(
7114 ch: PhidgetLCDHandle,
7115 font: PhidgetLCD_Font,
7116 xPosition: ::std::os::raw::c_int,
7117 yPosition: ::std::os::raw::c_int,
7118 text: *const ::std::os::raw::c_char,
7119 fptr: Phidget_AsyncCallback,
7120 ctx: *mut ::std::os::raw::c_void,
7121 );
7122}
7123extern "C" {
7124 pub fn PhidgetLCD_setAutoFlush(
7125 ch: PhidgetLCDHandle,
7126 autoFlush: ::std::os::raw::c_int,
7127 ) -> PhidgetReturnCode;
7128}
7129extern "C" {
7130 pub fn PhidgetLCD_getAutoFlush(
7131 ch: PhidgetLCDHandle,
7132 autoFlush: *mut ::std::os::raw::c_int,
7133 ) -> PhidgetReturnCode;
7134}
7135extern "C" {
7136 pub fn PhidgetLCD_setBacklight(ch: PhidgetLCDHandle, backlight: f64) -> PhidgetReturnCode;
7137}
7138extern "C" {
7139 pub fn PhidgetLCD_getBacklight(ch: PhidgetLCDHandle, backlight: *mut f64) -> PhidgetReturnCode;
7140}
7141extern "C" {
7142 pub fn PhidgetLCD_getMinBacklight(
7143 ch: PhidgetLCDHandle,
7144 minBacklight: *mut f64,
7145 ) -> PhidgetReturnCode;
7146}
7147extern "C" {
7148 pub fn PhidgetLCD_getMaxBacklight(
7149 ch: PhidgetLCDHandle,
7150 maxBacklight: *mut f64,
7151 ) -> PhidgetReturnCode;
7152}
7153extern "C" {
7154 pub fn PhidgetLCD_setContrast(ch: PhidgetLCDHandle, contrast: f64) -> PhidgetReturnCode;
7155}
7156extern "C" {
7157 pub fn PhidgetLCD_getContrast(ch: PhidgetLCDHandle, contrast: *mut f64) -> PhidgetReturnCode;
7158}
7159extern "C" {
7160 pub fn PhidgetLCD_getMinContrast(
7161 ch: PhidgetLCDHandle,
7162 minContrast: *mut f64,
7163 ) -> PhidgetReturnCode;
7164}
7165extern "C" {
7166 pub fn PhidgetLCD_getMaxContrast(
7167 ch: PhidgetLCDHandle,
7168 maxContrast: *mut f64,
7169 ) -> PhidgetReturnCode;
7170}
7171extern "C" {
7172 pub fn PhidgetLCD_setCursorBlink(
7173 ch: PhidgetLCDHandle,
7174 cursorBlink: ::std::os::raw::c_int,
7175 ) -> PhidgetReturnCode;
7176}
7177extern "C" {
7178 pub fn PhidgetLCD_getCursorBlink(
7179 ch: PhidgetLCDHandle,
7180 cursorBlink: *mut ::std::os::raw::c_int,
7181 ) -> PhidgetReturnCode;
7182}
7183extern "C" {
7184 pub fn PhidgetLCD_setCursorOn(
7185 ch: PhidgetLCDHandle,
7186 cursorOn: ::std::os::raw::c_int,
7187 ) -> PhidgetReturnCode;
7188}
7189extern "C" {
7190 pub fn PhidgetLCD_getCursorOn(
7191 ch: PhidgetLCDHandle,
7192 cursorOn: *mut ::std::os::raw::c_int,
7193 ) -> PhidgetReturnCode;
7194}
7195extern "C" {
7196 pub fn PhidgetLCD_setFrameBuffer(
7197 ch: PhidgetLCDHandle,
7198 frameBuffer: ::std::os::raw::c_int,
7199 ) -> PhidgetReturnCode;
7200}
7201extern "C" {
7202 pub fn PhidgetLCD_setFrameBuffer_async(
7203 ch: PhidgetLCDHandle,
7204 frameBuffer: ::std::os::raw::c_int,
7205 fptr: Phidget_AsyncCallback,
7206 ctx: *mut ::std::os::raw::c_void,
7207 );
7208}
7209extern "C" {
7210 pub fn PhidgetLCD_getFrameBuffer(
7211 ch: PhidgetLCDHandle,
7212 frameBuffer: *mut ::std::os::raw::c_int,
7213 ) -> PhidgetReturnCode;
7214}
7215extern "C" {
7216 pub fn PhidgetLCD_getHeight(
7217 ch: PhidgetLCDHandle,
7218 height: *mut ::std::os::raw::c_int,
7219 ) -> PhidgetReturnCode;
7220}
7221extern "C" {
7222 pub fn PhidgetLCD_setScreenSize(
7223 ch: PhidgetLCDHandle,
7224 screenSize: PhidgetLCD_ScreenSize,
7225 ) -> PhidgetReturnCode;
7226}
7227extern "C" {
7228 pub fn PhidgetLCD_getScreenSize(
7229 ch: PhidgetLCDHandle,
7230 screenSize: *mut PhidgetLCD_ScreenSize,
7231 ) -> PhidgetReturnCode;
7232}
7233extern "C" {
7234 pub fn PhidgetLCD_setSleeping(
7235 ch: PhidgetLCDHandle,
7236 sleeping: ::std::os::raw::c_int,
7237 ) -> PhidgetReturnCode;
7238}
7239extern "C" {
7240 pub fn PhidgetLCD_getSleeping(
7241 ch: PhidgetLCDHandle,
7242 sleeping: *mut ::std::os::raw::c_int,
7243 ) -> PhidgetReturnCode;
7244}
7245extern "C" {
7246 pub fn PhidgetLCD_getWidth(
7247 ch: PhidgetLCDHandle,
7248 width: *mut ::std::os::raw::c_int,
7249 ) -> PhidgetReturnCode;
7250}
7251#[repr(C)]
7252#[derive(Debug, Copy, Clone)]
7253pub struct _PhidgetLEDArray {
7254 _unused: [u8; 0],
7255}
7256pub type PhidgetLEDArrayHandle = *mut _PhidgetLEDArray;
7257extern "C" {
7258 pub fn PhidgetLEDArray_create(ch: *mut PhidgetLEDArrayHandle) -> PhidgetReturnCode;
7259}
7260extern "C" {
7261 pub fn PhidgetLEDArray_delete(ch: *mut PhidgetLEDArrayHandle) -> PhidgetReturnCode;
7262}
7263extern "C" {
7264 pub fn PhidgetLEDArray_setAnimation(
7265 ch: PhidgetLEDArrayHandle,
7266 animationID: i32,
7267 pattern: *const PhidgetLEDArray_RGBW,
7268 patternCount: usize,
7269 animationDescription: *mut PhidgetLEDArray_AnimationDescription,
7270 ) -> PhidgetReturnCode;
7271}
7272extern "C" {
7273 pub fn PhidgetLEDArray_clearLEDs(ch: PhidgetLEDArrayHandle) -> PhidgetReturnCode;
7274}
7275extern "C" {
7276 pub fn PhidgetLEDArray_setLEDs(
7277 ch: PhidgetLEDArrayHandle,
7278 offset: u32,
7279 leds: *const PhidgetLEDArray_RGBW,
7280 ledCount: usize,
7281 fadeTime: u32,
7282 ) -> PhidgetReturnCode;
7283}
7284extern "C" {
7285 pub fn PhidgetLEDArray_setLEDs_async(
7286 ch: PhidgetLEDArrayHandle,
7287 offset: u32,
7288 leds: *const PhidgetLEDArray_RGBW,
7289 ledCount: usize,
7290 fadeTime: u32,
7291 fptr: Phidget_AsyncCallback,
7292 ctx: *mut ::std::os::raw::c_void,
7293 );
7294}
7295extern "C" {
7296 pub fn PhidgetLEDArray_stopAnimation(
7297 ch: PhidgetLEDArrayHandle,
7298 animationID: i32,
7299 ) -> PhidgetReturnCode;
7300}
7301extern "C" {
7302 pub fn PhidgetLEDArray_synchronizeAnimations(ch: PhidgetLEDArrayHandle) -> PhidgetReturnCode;
7303}
7304extern "C" {
7305 pub fn PhidgetLEDArray_getMinAnimationID(
7306 ch: PhidgetLEDArrayHandle,
7307 minAnimationID: *mut i32,
7308 ) -> PhidgetReturnCode;
7309}
7310extern "C" {
7311 pub fn PhidgetLEDArray_getMaxAnimationID(
7312 ch: PhidgetLEDArrayHandle,
7313 maxAnimationID: *mut i32,
7314 ) -> PhidgetReturnCode;
7315}
7316extern "C" {
7317 pub fn PhidgetLEDArray_getMinAnimationPatternCount(
7318 ch: PhidgetLEDArrayHandle,
7319 minAnimationPatternCount: *mut u32,
7320 ) -> PhidgetReturnCode;
7321}
7322extern "C" {
7323 pub fn PhidgetLEDArray_getMaxAnimationPatternCount(
7324 ch: PhidgetLEDArrayHandle,
7325 maxAnimationPatternCount: *mut u32,
7326 ) -> PhidgetReturnCode;
7327}
7328extern "C" {
7329 pub fn PhidgetLEDArray_setBrightness(
7330 ch: PhidgetLEDArrayHandle,
7331 brightness: f64,
7332 ) -> PhidgetReturnCode;
7333}
7334extern "C" {
7335 pub fn PhidgetLEDArray_getBrightness(
7336 ch: PhidgetLEDArrayHandle,
7337 brightness: *mut f64,
7338 ) -> PhidgetReturnCode;
7339}
7340extern "C" {
7341 pub fn PhidgetLEDArray_getMinBrightness(
7342 ch: PhidgetLEDArrayHandle,
7343 minBrightness: *mut f64,
7344 ) -> PhidgetReturnCode;
7345}
7346extern "C" {
7347 pub fn PhidgetLEDArray_getMaxBrightness(
7348 ch: PhidgetLEDArrayHandle,
7349 maxBrightness: *mut f64,
7350 ) -> PhidgetReturnCode;
7351}
7352extern "C" {
7353 pub fn PhidgetLEDArray_getMinFadeTime(
7354 ch: PhidgetLEDArrayHandle,
7355 minFadeTime: *mut u32,
7356 ) -> PhidgetReturnCode;
7357}
7358extern "C" {
7359 pub fn PhidgetLEDArray_getMaxFadeTime(
7360 ch: PhidgetLEDArrayHandle,
7361 maxFadeTime: *mut u32,
7362 ) -> PhidgetReturnCode;
7363}
7364extern "C" {
7365 pub fn PhidgetLEDArray_setGamma(ch: PhidgetLEDArrayHandle, gamma: f64) -> PhidgetReturnCode;
7366}
7367extern "C" {
7368 pub fn PhidgetLEDArray_getGamma(
7369 ch: PhidgetLEDArrayHandle,
7370 gamma: *mut f64,
7371 ) -> PhidgetReturnCode;
7372}
7373extern "C" {
7374 pub fn PhidgetLEDArray_getMinLEDCount(
7375 ch: PhidgetLEDArrayHandle,
7376 minLEDCount: *mut u32,
7377 ) -> PhidgetReturnCode;
7378}
7379extern "C" {
7380 pub fn PhidgetLEDArray_getMaxLEDCount(
7381 ch: PhidgetLEDArrayHandle,
7382 maxLEDCount: *mut u32,
7383 ) -> PhidgetReturnCode;
7384}
7385extern "C" {
7386 pub fn PhidgetLEDArray_setPowerEnabled(
7387 ch: PhidgetLEDArrayHandle,
7388 powerEnabled: ::std::os::raw::c_int,
7389 ) -> PhidgetReturnCode;
7390}
7391extern "C" {
7392 pub fn PhidgetLEDArray_getPowerEnabled(
7393 ch: PhidgetLEDArrayHandle,
7394 powerEnabled: *mut ::std::os::raw::c_int,
7395 ) -> PhidgetReturnCode;
7396}
7397extern "C" {
7398 pub fn PhidgetLEDArray_setProtocol(
7399 ch: PhidgetLEDArrayHandle,
7400 protocol: PhidgetLEDArray_Protocol,
7401 ) -> PhidgetReturnCode;
7402}
7403extern "C" {
7404 pub fn PhidgetLEDArray_getProtocol(
7405 ch: PhidgetLEDArrayHandle,
7406 protocol: *mut PhidgetLEDArray_Protocol,
7407 ) -> PhidgetReturnCode;
7408}
7409#[repr(C)]
7410#[derive(Debug, Copy, Clone)]
7411pub struct _PhidgetLightSensor {
7412 _unused: [u8; 0],
7413}
7414pub type PhidgetLightSensorHandle = *mut _PhidgetLightSensor;
7415extern "C" {
7416 pub fn PhidgetLightSensor_create(ch: *mut PhidgetLightSensorHandle) -> PhidgetReturnCode;
7417}
7418extern "C" {
7419 pub fn PhidgetLightSensor_delete(ch: *mut PhidgetLightSensorHandle) -> PhidgetReturnCode;
7420}
7421extern "C" {
7422 pub fn PhidgetLightSensor_setDataInterval(
7423 ch: PhidgetLightSensorHandle,
7424 dataInterval: u32,
7425 ) -> PhidgetReturnCode;
7426}
7427extern "C" {
7428 pub fn PhidgetLightSensor_getDataInterval(
7429 ch: PhidgetLightSensorHandle,
7430 dataInterval: *mut u32,
7431 ) -> PhidgetReturnCode;
7432}
7433extern "C" {
7434 pub fn PhidgetLightSensor_getMinDataInterval(
7435 ch: PhidgetLightSensorHandle,
7436 minDataInterval: *mut u32,
7437 ) -> PhidgetReturnCode;
7438}
7439extern "C" {
7440 pub fn PhidgetLightSensor_getMaxDataInterval(
7441 ch: PhidgetLightSensorHandle,
7442 maxDataInterval: *mut u32,
7443 ) -> PhidgetReturnCode;
7444}
7445extern "C" {
7446 pub fn PhidgetLightSensor_setDataRate(
7447 ch: PhidgetLightSensorHandle,
7448 dataRate: f64,
7449 ) -> PhidgetReturnCode;
7450}
7451extern "C" {
7452 pub fn PhidgetLightSensor_getDataRate(
7453 ch: PhidgetLightSensorHandle,
7454 dataRate: *mut f64,
7455 ) -> PhidgetReturnCode;
7456}
7457extern "C" {
7458 pub fn PhidgetLightSensor_getMinDataRate(
7459 ch: PhidgetLightSensorHandle,
7460 minDataRate: *mut f64,
7461 ) -> PhidgetReturnCode;
7462}
7463extern "C" {
7464 pub fn PhidgetLightSensor_getMaxDataRate(
7465 ch: PhidgetLightSensorHandle,
7466 maxDataRate: *mut f64,
7467 ) -> PhidgetReturnCode;
7468}
7469extern "C" {
7470 pub fn PhidgetLightSensor_getIlluminance(
7471 ch: PhidgetLightSensorHandle,
7472 illuminance: *mut f64,
7473 ) -> PhidgetReturnCode;
7474}
7475extern "C" {
7476 pub fn PhidgetLightSensor_getMinIlluminance(
7477 ch: PhidgetLightSensorHandle,
7478 minIlluminance: *mut f64,
7479 ) -> PhidgetReturnCode;
7480}
7481extern "C" {
7482 pub fn PhidgetLightSensor_getMaxIlluminance(
7483 ch: PhidgetLightSensorHandle,
7484 maxIlluminance: *mut f64,
7485 ) -> PhidgetReturnCode;
7486}
7487extern "C" {
7488 pub fn PhidgetLightSensor_setIlluminanceChangeTrigger(
7489 ch: PhidgetLightSensorHandle,
7490 illuminanceChangeTrigger: f64,
7491 ) -> PhidgetReturnCode;
7492}
7493extern "C" {
7494 pub fn PhidgetLightSensor_getIlluminanceChangeTrigger(
7495 ch: PhidgetLightSensorHandle,
7496 illuminanceChangeTrigger: *mut f64,
7497 ) -> PhidgetReturnCode;
7498}
7499extern "C" {
7500 pub fn PhidgetLightSensor_getMinIlluminanceChangeTrigger(
7501 ch: PhidgetLightSensorHandle,
7502 minIlluminanceChangeTrigger: *mut f64,
7503 ) -> PhidgetReturnCode;
7504}
7505extern "C" {
7506 pub fn PhidgetLightSensor_getMaxIlluminanceChangeTrigger(
7507 ch: PhidgetLightSensorHandle,
7508 maxIlluminanceChangeTrigger: *mut f64,
7509 ) -> PhidgetReturnCode;
7510}
7511pub type PhidgetLightSensor_OnIlluminanceChangeCallback = ::std::option::Option<
7512 unsafe extern "C" fn(
7513 ch: PhidgetLightSensorHandle,
7514 ctx: *mut ::std::os::raw::c_void,
7515 illuminance: f64,
7516 ),
7517>;
7518extern "C" {
7519 pub fn PhidgetLightSensor_setOnIlluminanceChangeHandler(
7520 ch: PhidgetLightSensorHandle,
7521 fptr: PhidgetLightSensor_OnIlluminanceChangeCallback,
7522 ctx: *mut ::std::os::raw::c_void,
7523 ) -> PhidgetReturnCode;
7524}
7525#[repr(C)]
7526#[derive(Debug, Copy, Clone)]
7527pub struct _PhidgetMagnetometer {
7528 _unused: [u8; 0],
7529}
7530pub type PhidgetMagnetometerHandle = *mut _PhidgetMagnetometer;
7531extern "C" {
7532 pub fn PhidgetMagnetometer_create(ch: *mut PhidgetMagnetometerHandle) -> PhidgetReturnCode;
7533}
7534extern "C" {
7535 pub fn PhidgetMagnetometer_delete(ch: *mut PhidgetMagnetometerHandle) -> PhidgetReturnCode;
7536}
7537extern "C" {
7538 pub fn PhidgetMagnetometer_setCorrectionParameters(
7539 ch: PhidgetMagnetometerHandle,
7540 magneticField: f64,
7541 offset0: f64,
7542 offset1: f64,
7543 offset2: f64,
7544 gain0: f64,
7545 gain1: f64,
7546 gain2: f64,
7547 T0: f64,
7548 T1: f64,
7549 T2: f64,
7550 T3: f64,
7551 T4: f64,
7552 T5: f64,
7553 ) -> PhidgetReturnCode;
7554}
7555extern "C" {
7556 pub fn PhidgetMagnetometer_resetCorrectionParameters(
7557 ch: PhidgetMagnetometerHandle,
7558 ) -> PhidgetReturnCode;
7559}
7560extern "C" {
7561 pub fn PhidgetMagnetometer_saveCorrectionParameters(
7562 ch: PhidgetMagnetometerHandle,
7563 ) -> PhidgetReturnCode;
7564}
7565extern "C" {
7566 pub fn PhidgetMagnetometer_getAxisCount(
7567 ch: PhidgetMagnetometerHandle,
7568 axisCount: *mut ::std::os::raw::c_int,
7569 ) -> PhidgetReturnCode;
7570}
7571extern "C" {
7572 pub fn PhidgetMagnetometer_setDataInterval(
7573 ch: PhidgetMagnetometerHandle,
7574 dataInterval: u32,
7575 ) -> PhidgetReturnCode;
7576}
7577extern "C" {
7578 pub fn PhidgetMagnetometer_getDataInterval(
7579 ch: PhidgetMagnetometerHandle,
7580 dataInterval: *mut u32,
7581 ) -> PhidgetReturnCode;
7582}
7583extern "C" {
7584 pub fn PhidgetMagnetometer_getMinDataInterval(
7585 ch: PhidgetMagnetometerHandle,
7586 minDataInterval: *mut u32,
7587 ) -> PhidgetReturnCode;
7588}
7589extern "C" {
7590 pub fn PhidgetMagnetometer_getMaxDataInterval(
7591 ch: PhidgetMagnetometerHandle,
7592 maxDataInterval: *mut u32,
7593 ) -> PhidgetReturnCode;
7594}
7595extern "C" {
7596 pub fn PhidgetMagnetometer_setDataRate(
7597 ch: PhidgetMagnetometerHandle,
7598 dataRate: f64,
7599 ) -> PhidgetReturnCode;
7600}
7601extern "C" {
7602 pub fn PhidgetMagnetometer_getDataRate(
7603 ch: PhidgetMagnetometerHandle,
7604 dataRate: *mut f64,
7605 ) -> PhidgetReturnCode;
7606}
7607extern "C" {
7608 pub fn PhidgetMagnetometer_getMinDataRate(
7609 ch: PhidgetMagnetometerHandle,
7610 minDataRate: *mut f64,
7611 ) -> PhidgetReturnCode;
7612}
7613extern "C" {
7614 pub fn PhidgetMagnetometer_getMaxDataRate(
7615 ch: PhidgetMagnetometerHandle,
7616 maxDataRate: *mut f64,
7617 ) -> PhidgetReturnCode;
7618}
7619extern "C" {
7620 pub fn PhidgetMagnetometer_setHeatingEnabled(
7621 ch: PhidgetMagnetometerHandle,
7622 heatingEnabled: ::std::os::raw::c_int,
7623 ) -> PhidgetReturnCode;
7624}
7625extern "C" {
7626 pub fn PhidgetMagnetometer_getHeatingEnabled(
7627 ch: PhidgetMagnetometerHandle,
7628 heatingEnabled: *mut ::std::os::raw::c_int,
7629 ) -> PhidgetReturnCode;
7630}
7631extern "C" {
7632 pub fn PhidgetMagnetometer_getMagneticField(
7633 ch: PhidgetMagnetometerHandle,
7634 magneticField: *mut [f64; 3usize],
7635 ) -> PhidgetReturnCode;
7636}
7637extern "C" {
7638 pub fn PhidgetMagnetometer_getMinMagneticField(
7639 ch: PhidgetMagnetometerHandle,
7640 minMagneticField: *mut [f64; 3usize],
7641 ) -> PhidgetReturnCode;
7642}
7643extern "C" {
7644 pub fn PhidgetMagnetometer_getMaxMagneticField(
7645 ch: PhidgetMagnetometerHandle,
7646 maxMagneticField: *mut [f64; 3usize],
7647 ) -> PhidgetReturnCode;
7648}
7649extern "C" {
7650 pub fn PhidgetMagnetometer_setMagneticFieldChangeTrigger(
7651 ch: PhidgetMagnetometerHandle,
7652 magneticFieldChangeTrigger: f64,
7653 ) -> PhidgetReturnCode;
7654}
7655extern "C" {
7656 pub fn PhidgetMagnetometer_getMagneticFieldChangeTrigger(
7657 ch: PhidgetMagnetometerHandle,
7658 magneticFieldChangeTrigger: *mut f64,
7659 ) -> PhidgetReturnCode;
7660}
7661extern "C" {
7662 pub fn PhidgetMagnetometer_getMinMagneticFieldChangeTrigger(
7663 ch: PhidgetMagnetometerHandle,
7664 minMagneticFieldChangeTrigger: *mut f64,
7665 ) -> PhidgetReturnCode;
7666}
7667extern "C" {
7668 pub fn PhidgetMagnetometer_getMaxMagneticFieldChangeTrigger(
7669 ch: PhidgetMagnetometerHandle,
7670 maxMagneticFieldChangeTrigger: *mut f64,
7671 ) -> PhidgetReturnCode;
7672}
7673extern "C" {
7674 pub fn PhidgetMagnetometer_getTimestamp(
7675 ch: PhidgetMagnetometerHandle,
7676 timestamp: *mut f64,
7677 ) -> PhidgetReturnCode;
7678}
7679pub type PhidgetMagnetometer_OnMagneticFieldChangeCallback = ::std::option::Option<
7680 unsafe extern "C" fn(
7681 ch: PhidgetMagnetometerHandle,
7682 ctx: *mut ::std::os::raw::c_void,
7683 magneticField: *const f64,
7684 timestamp: f64,
7685 ),
7686>;
7687extern "C" {
7688 pub fn PhidgetMagnetometer_setOnMagneticFieldChangeHandler(
7689 ch: PhidgetMagnetometerHandle,
7690 fptr: PhidgetMagnetometer_OnMagneticFieldChangeCallback,
7691 ctx: *mut ::std::os::raw::c_void,
7692 ) -> PhidgetReturnCode;
7693}
7694#[repr(C)]
7695#[derive(Debug, Copy, Clone)]
7696pub struct _PhidgetMeshDongle {
7697 _unused: [u8; 0],
7698}
7699pub type PhidgetMeshDongleHandle = *mut _PhidgetMeshDongle;
7700extern "C" {
7701 pub fn PhidgetMeshDongle_create(ch: *mut PhidgetMeshDongleHandle) -> PhidgetReturnCode;
7702}
7703extern "C" {
7704 pub fn PhidgetMeshDongle_delete(ch: *mut PhidgetMeshDongleHandle) -> PhidgetReturnCode;
7705}
7706#[repr(C)]
7707#[derive(Debug, Copy, Clone)]
7708pub struct _PhidgetMotorPositionController {
7709 _unused: [u8; 0],
7710}
7711pub type PhidgetMotorPositionControllerHandle = *mut _PhidgetMotorPositionController;
7712extern "C" {
7713 pub fn PhidgetMotorPositionController_create(
7714 ch: *mut PhidgetMotorPositionControllerHandle,
7715 ) -> PhidgetReturnCode;
7716}
7717extern "C" {
7718 pub fn PhidgetMotorPositionController_delete(
7719 ch: *mut PhidgetMotorPositionControllerHandle,
7720 ) -> PhidgetReturnCode;
7721}
7722extern "C" {
7723 pub fn PhidgetMotorPositionController_enableFailsafe(
7724 ch: PhidgetMotorPositionControllerHandle,
7725 failsafeTime: u32,
7726 ) -> PhidgetReturnCode;
7727}
7728extern "C" {
7729 pub fn PhidgetMotorPositionController_addPositionOffset(
7730 ch: PhidgetMotorPositionControllerHandle,
7731 positionOffset: f64,
7732 ) -> PhidgetReturnCode;
7733}
7734extern "C" {
7735 pub fn PhidgetMotorPositionController_resetFailsafe(
7736 ch: PhidgetMotorPositionControllerHandle,
7737 ) -> PhidgetReturnCode;
7738}
7739extern "C" {
7740 pub fn PhidgetMotorPositionController_setAcceleration(
7741 ch: PhidgetMotorPositionControllerHandle,
7742 acceleration: f64,
7743 ) -> PhidgetReturnCode;
7744}
7745extern "C" {
7746 pub fn PhidgetMotorPositionController_getAcceleration(
7747 ch: PhidgetMotorPositionControllerHandle,
7748 acceleration: *mut f64,
7749 ) -> PhidgetReturnCode;
7750}
7751extern "C" {
7752 pub fn PhidgetMotorPositionController_getMinAcceleration(
7753 ch: PhidgetMotorPositionControllerHandle,
7754 minAcceleration: *mut f64,
7755 ) -> PhidgetReturnCode;
7756}
7757extern "C" {
7758 pub fn PhidgetMotorPositionController_getMaxAcceleration(
7759 ch: PhidgetMotorPositionControllerHandle,
7760 maxAcceleration: *mut f64,
7761 ) -> PhidgetReturnCode;
7762}
7763extern "C" {
7764 pub fn PhidgetMotorPositionController_getActiveCurrentLimit(
7765 ch: PhidgetMotorPositionControllerHandle,
7766 activeCurrentLimit: *mut f64,
7767 ) -> PhidgetReturnCode;
7768}
7769extern "C" {
7770 pub fn PhidgetMotorPositionController_setCurrentLimit(
7771 ch: PhidgetMotorPositionControllerHandle,
7772 currentLimit: f64,
7773 ) -> PhidgetReturnCode;
7774}
7775extern "C" {
7776 pub fn PhidgetMotorPositionController_getCurrentLimit(
7777 ch: PhidgetMotorPositionControllerHandle,
7778 currentLimit: *mut f64,
7779 ) -> PhidgetReturnCode;
7780}
7781extern "C" {
7782 pub fn PhidgetMotorPositionController_getMinCurrentLimit(
7783 ch: PhidgetMotorPositionControllerHandle,
7784 minCurrentLimit: *mut f64,
7785 ) -> PhidgetReturnCode;
7786}
7787extern "C" {
7788 pub fn PhidgetMotorPositionController_getMaxCurrentLimit(
7789 ch: PhidgetMotorPositionControllerHandle,
7790 maxCurrentLimit: *mut f64,
7791 ) -> PhidgetReturnCode;
7792}
7793extern "C" {
7794 pub fn PhidgetMotorPositionController_setCurrentRegulatorGain(
7795 ch: PhidgetMotorPositionControllerHandle,
7796 currentRegulatorGain: f64,
7797 ) -> PhidgetReturnCode;
7798}
7799extern "C" {
7800 pub fn PhidgetMotorPositionController_getCurrentRegulatorGain(
7801 ch: PhidgetMotorPositionControllerHandle,
7802 currentRegulatorGain: *mut f64,
7803 ) -> PhidgetReturnCode;
7804}
7805extern "C" {
7806 pub fn PhidgetMotorPositionController_getMinCurrentRegulatorGain(
7807 ch: PhidgetMotorPositionControllerHandle,
7808 minCurrentRegulatorGain: *mut f64,
7809 ) -> PhidgetReturnCode;
7810}
7811extern "C" {
7812 pub fn PhidgetMotorPositionController_getMaxCurrentRegulatorGain(
7813 ch: PhidgetMotorPositionControllerHandle,
7814 maxCurrentRegulatorGain: *mut f64,
7815 ) -> PhidgetReturnCode;
7816}
7817extern "C" {
7818 pub fn PhidgetMotorPositionController_setDataInterval(
7819 ch: PhidgetMotorPositionControllerHandle,
7820 dataInterval: u32,
7821 ) -> PhidgetReturnCode;
7822}
7823extern "C" {
7824 pub fn PhidgetMotorPositionController_getDataInterval(
7825 ch: PhidgetMotorPositionControllerHandle,
7826 dataInterval: *mut u32,
7827 ) -> PhidgetReturnCode;
7828}
7829extern "C" {
7830 pub fn PhidgetMotorPositionController_getMinDataInterval(
7831 ch: PhidgetMotorPositionControllerHandle,
7832 minDataInterval: *mut u32,
7833 ) -> PhidgetReturnCode;
7834}
7835extern "C" {
7836 pub fn PhidgetMotorPositionController_getMaxDataInterval(
7837 ch: PhidgetMotorPositionControllerHandle,
7838 maxDataInterval: *mut u32,
7839 ) -> PhidgetReturnCode;
7840}
7841extern "C" {
7842 pub fn PhidgetMotorPositionController_setDataRate(
7843 ch: PhidgetMotorPositionControllerHandle,
7844 dataRate: f64,
7845 ) -> PhidgetReturnCode;
7846}
7847extern "C" {
7848 pub fn PhidgetMotorPositionController_getDataRate(
7849 ch: PhidgetMotorPositionControllerHandle,
7850 dataRate: *mut f64,
7851 ) -> PhidgetReturnCode;
7852}
7853extern "C" {
7854 pub fn PhidgetMotorPositionController_getMinDataRate(
7855 ch: PhidgetMotorPositionControllerHandle,
7856 minDataRate: *mut f64,
7857 ) -> PhidgetReturnCode;
7858}
7859extern "C" {
7860 pub fn PhidgetMotorPositionController_getMaxDataRate(
7861 ch: PhidgetMotorPositionControllerHandle,
7862 maxDataRate: *mut f64,
7863 ) -> PhidgetReturnCode;
7864}
7865extern "C" {
7866 pub fn PhidgetMotorPositionController_setDeadBand(
7867 ch: PhidgetMotorPositionControllerHandle,
7868 deadBand: f64,
7869 ) -> PhidgetReturnCode;
7870}
7871extern "C" {
7872 pub fn PhidgetMotorPositionController_getDeadBand(
7873 ch: PhidgetMotorPositionControllerHandle,
7874 deadBand: *mut f64,
7875 ) -> PhidgetReturnCode;
7876}
7877extern "C" {
7878 pub fn PhidgetMotorPositionController_getDutyCycle(
7879 ch: PhidgetMotorPositionControllerHandle,
7880 dutyCycle: *mut f64,
7881 ) -> PhidgetReturnCode;
7882}
7883extern "C" {
7884 pub fn PhidgetMotorPositionController_setEngaged(
7885 ch: PhidgetMotorPositionControllerHandle,
7886 engaged: ::std::os::raw::c_int,
7887 ) -> PhidgetReturnCode;
7888}
7889extern "C" {
7890 pub fn PhidgetMotorPositionController_getEngaged(
7891 ch: PhidgetMotorPositionControllerHandle,
7892 engaged: *mut ::std::os::raw::c_int,
7893 ) -> PhidgetReturnCode;
7894}
7895extern "C" {
7896 pub fn PhidgetMotorPositionController_getExpectedPosition(
7897 ch: PhidgetMotorPositionControllerHandle,
7898 expectedPosition: *mut f64,
7899 ) -> PhidgetReturnCode;
7900}
7901extern "C" {
7902 pub fn PhidgetMotorPositionController_setEnableExpectedPosition(
7903 ch: PhidgetMotorPositionControllerHandle,
7904 enableExpectedPosition: ::std::os::raw::c_int,
7905 ) -> PhidgetReturnCode;
7906}
7907extern "C" {
7908 pub fn PhidgetMotorPositionController_getEnableExpectedPosition(
7909 ch: PhidgetMotorPositionControllerHandle,
7910 enableExpectedPosition: *mut ::std::os::raw::c_int,
7911 ) -> PhidgetReturnCode;
7912}
7913extern "C" {
7914 pub fn PhidgetMotorPositionController_setFailsafeBrakingEnabled(
7915 ch: PhidgetMotorPositionControllerHandle,
7916 failsafeBrakingEnabled: ::std::os::raw::c_int,
7917 ) -> PhidgetReturnCode;
7918}
7919extern "C" {
7920 pub fn PhidgetMotorPositionController_getFailsafeBrakingEnabled(
7921 ch: PhidgetMotorPositionControllerHandle,
7922 failsafeBrakingEnabled: *mut ::std::os::raw::c_int,
7923 ) -> PhidgetReturnCode;
7924}
7925extern "C" {
7926 pub fn PhidgetMotorPositionController_setFailsafeCurrentLimit(
7927 ch: PhidgetMotorPositionControllerHandle,
7928 failsafeCurrentLimit: f64,
7929 ) -> PhidgetReturnCode;
7930}
7931extern "C" {
7932 pub fn PhidgetMotorPositionController_getFailsafeCurrentLimit(
7933 ch: PhidgetMotorPositionControllerHandle,
7934 failsafeCurrentLimit: *mut f64,
7935 ) -> PhidgetReturnCode;
7936}
7937extern "C" {
7938 pub fn PhidgetMotorPositionController_getMinFailsafeTime(
7939 ch: PhidgetMotorPositionControllerHandle,
7940 minFailsafeTime: *mut u32,
7941 ) -> PhidgetReturnCode;
7942}
7943extern "C" {
7944 pub fn PhidgetMotorPositionController_getMaxFailsafeTime(
7945 ch: PhidgetMotorPositionControllerHandle,
7946 maxFailsafeTime: *mut u32,
7947 ) -> PhidgetReturnCode;
7948}
7949extern "C" {
7950 pub fn PhidgetMotorPositionController_setFanMode(
7951 ch: PhidgetMotorPositionControllerHandle,
7952 fanMode: Phidget_FanMode,
7953 ) -> PhidgetReturnCode;
7954}
7955extern "C" {
7956 pub fn PhidgetMotorPositionController_getFanMode(
7957 ch: PhidgetMotorPositionControllerHandle,
7958 fanMode: *mut Phidget_FanMode,
7959 ) -> PhidgetReturnCode;
7960}
7961extern "C" {
7962 pub fn PhidgetMotorPositionController_setInductance(
7963 ch: PhidgetMotorPositionControllerHandle,
7964 inductance: f64,
7965 ) -> PhidgetReturnCode;
7966}
7967extern "C" {
7968 pub fn PhidgetMotorPositionController_getInductance(
7969 ch: PhidgetMotorPositionControllerHandle,
7970 inductance: *mut f64,
7971 ) -> PhidgetReturnCode;
7972}
7973extern "C" {
7974 pub fn PhidgetMotorPositionController_getMinInductance(
7975 ch: PhidgetMotorPositionControllerHandle,
7976 minInductance: *mut f64,
7977 ) -> PhidgetReturnCode;
7978}
7979extern "C" {
7980 pub fn PhidgetMotorPositionController_getMaxInductance(
7981 ch: PhidgetMotorPositionControllerHandle,
7982 maxInductance: *mut f64,
7983 ) -> PhidgetReturnCode;
7984}
7985extern "C" {
7986 pub fn PhidgetMotorPositionController_setIOMode(
7987 ch: PhidgetMotorPositionControllerHandle,
7988 IOMode: Phidget_EncoderIOMode,
7989 ) -> PhidgetReturnCode;
7990}
7991extern "C" {
7992 pub fn PhidgetMotorPositionController_getIOMode(
7993 ch: PhidgetMotorPositionControllerHandle,
7994 IOMode: *mut Phidget_EncoderIOMode,
7995 ) -> PhidgetReturnCode;
7996}
7997extern "C" {
7998 pub fn PhidgetMotorPositionController_setKd(
7999 ch: PhidgetMotorPositionControllerHandle,
8000 kd: f64,
8001 ) -> PhidgetReturnCode;
8002}
8003extern "C" {
8004 pub fn PhidgetMotorPositionController_getKd(
8005 ch: PhidgetMotorPositionControllerHandle,
8006 kd: *mut f64,
8007 ) -> PhidgetReturnCode;
8008}
8009extern "C" {
8010 pub fn PhidgetMotorPositionController_setKi(
8011 ch: PhidgetMotorPositionControllerHandle,
8012 ki: f64,
8013 ) -> PhidgetReturnCode;
8014}
8015extern "C" {
8016 pub fn PhidgetMotorPositionController_getKi(
8017 ch: PhidgetMotorPositionControllerHandle,
8018 ki: *mut f64,
8019 ) -> PhidgetReturnCode;
8020}
8021extern "C" {
8022 pub fn PhidgetMotorPositionController_setKp(
8023 ch: PhidgetMotorPositionControllerHandle,
8024 kp: f64,
8025 ) -> PhidgetReturnCode;
8026}
8027extern "C" {
8028 pub fn PhidgetMotorPositionController_getKp(
8029 ch: PhidgetMotorPositionControllerHandle,
8030 kp: *mut f64,
8031 ) -> PhidgetReturnCode;
8032}
8033extern "C" {
8034 pub fn PhidgetMotorPositionController_setNormalizePID(
8035 ch: PhidgetMotorPositionControllerHandle,
8036 normalizePID: ::std::os::raw::c_int,
8037 ) -> PhidgetReturnCode;
8038}
8039extern "C" {
8040 pub fn PhidgetMotorPositionController_getNormalizePID(
8041 ch: PhidgetMotorPositionControllerHandle,
8042 normalizePID: *mut ::std::os::raw::c_int,
8043 ) -> PhidgetReturnCode;
8044}
8045extern "C" {
8046 pub fn PhidgetMotorPositionController_getPosition(
8047 ch: PhidgetMotorPositionControllerHandle,
8048 position: *mut f64,
8049 ) -> PhidgetReturnCode;
8050}
8051extern "C" {
8052 pub fn PhidgetMotorPositionController_getMinPosition(
8053 ch: PhidgetMotorPositionControllerHandle,
8054 minPosition: *mut f64,
8055 ) -> PhidgetReturnCode;
8056}
8057extern "C" {
8058 pub fn PhidgetMotorPositionController_getMaxPosition(
8059 ch: PhidgetMotorPositionControllerHandle,
8060 maxPosition: *mut f64,
8061 ) -> PhidgetReturnCode;
8062}
8063extern "C" {
8064 pub fn PhidgetMotorPositionController_setPositionType(
8065 ch: PhidgetMotorPositionControllerHandle,
8066 positionType: Phidget_PositionType,
8067 ) -> PhidgetReturnCode;
8068}
8069extern "C" {
8070 pub fn PhidgetMotorPositionController_getPositionType(
8071 ch: PhidgetMotorPositionControllerHandle,
8072 positionType: *mut Phidget_PositionType,
8073 ) -> PhidgetReturnCode;
8074}
8075extern "C" {
8076 pub fn PhidgetMotorPositionController_setRescaleFactor(
8077 ch: PhidgetMotorPositionControllerHandle,
8078 rescaleFactor: f64,
8079 ) -> PhidgetReturnCode;
8080}
8081extern "C" {
8082 pub fn PhidgetMotorPositionController_getRescaleFactor(
8083 ch: PhidgetMotorPositionControllerHandle,
8084 rescaleFactor: *mut f64,
8085 ) -> PhidgetReturnCode;
8086}
8087extern "C" {
8088 pub fn PhidgetMotorPositionController_setStallVelocity(
8089 ch: PhidgetMotorPositionControllerHandle,
8090 stallVelocity: f64,
8091 ) -> PhidgetReturnCode;
8092}
8093extern "C" {
8094 pub fn PhidgetMotorPositionController_getStallVelocity(
8095 ch: PhidgetMotorPositionControllerHandle,
8096 stallVelocity: *mut f64,
8097 ) -> PhidgetReturnCode;
8098}
8099extern "C" {
8100 pub fn PhidgetMotorPositionController_getMinStallVelocity(
8101 ch: PhidgetMotorPositionControllerHandle,
8102 minStallVelocity: *mut f64,
8103 ) -> PhidgetReturnCode;
8104}
8105extern "C" {
8106 pub fn PhidgetMotorPositionController_getMaxStallVelocity(
8107 ch: PhidgetMotorPositionControllerHandle,
8108 maxStallVelocity: *mut f64,
8109 ) -> PhidgetReturnCode;
8110}
8111extern "C" {
8112 pub fn PhidgetMotorPositionController_setSurgeCurrentLimit(
8113 ch: PhidgetMotorPositionControllerHandle,
8114 surgeCurrentLimit: f64,
8115 ) -> PhidgetReturnCode;
8116}
8117extern "C" {
8118 pub fn PhidgetMotorPositionController_getSurgeCurrentLimit(
8119 ch: PhidgetMotorPositionControllerHandle,
8120 surgeCurrentLimit: *mut f64,
8121 ) -> PhidgetReturnCode;
8122}
8123extern "C" {
8124 pub fn PhidgetMotorPositionController_getMinSurgeCurrentLimit(
8125 ch: PhidgetMotorPositionControllerHandle,
8126 minSurgeCurrentLimit: *mut f64,
8127 ) -> PhidgetReturnCode;
8128}
8129extern "C" {
8130 pub fn PhidgetMotorPositionController_getMaxSurgeCurrentLimit(
8131 ch: PhidgetMotorPositionControllerHandle,
8132 maxSurgeCurrentLimit: *mut f64,
8133 ) -> PhidgetReturnCode;
8134}
8135extern "C" {
8136 pub fn PhidgetMotorPositionController_setTargetPosition(
8137 ch: PhidgetMotorPositionControllerHandle,
8138 targetPosition: f64,
8139 ) -> PhidgetReturnCode;
8140}
8141extern "C" {
8142 pub fn PhidgetMotorPositionController_setTargetPosition_async(
8143 ch: PhidgetMotorPositionControllerHandle,
8144 targetPosition: f64,
8145 fptr: Phidget_AsyncCallback,
8146 ctx: *mut ::std::os::raw::c_void,
8147 );
8148}
8149extern "C" {
8150 pub fn PhidgetMotorPositionController_getTargetPosition(
8151 ch: PhidgetMotorPositionControllerHandle,
8152 targetPosition: *mut f64,
8153 ) -> PhidgetReturnCode;
8154}
8155extern "C" {
8156 pub fn PhidgetMotorPositionController_setVelocityLimit(
8157 ch: PhidgetMotorPositionControllerHandle,
8158 velocityLimit: f64,
8159 ) -> PhidgetReturnCode;
8160}
8161extern "C" {
8162 pub fn PhidgetMotorPositionController_getVelocityLimit(
8163 ch: PhidgetMotorPositionControllerHandle,
8164 velocityLimit: *mut f64,
8165 ) -> PhidgetReturnCode;
8166}
8167extern "C" {
8168 pub fn PhidgetMotorPositionController_getMinVelocityLimit(
8169 ch: PhidgetMotorPositionControllerHandle,
8170 minVelocityLimit: *mut f64,
8171 ) -> PhidgetReturnCode;
8172}
8173extern "C" {
8174 pub fn PhidgetMotorPositionController_getMaxVelocityLimit(
8175 ch: PhidgetMotorPositionControllerHandle,
8176 maxVelocityLimit: *mut f64,
8177 ) -> PhidgetReturnCode;
8178}
8179pub type PhidgetMotorPositionController_OnDutyCycleUpdateCallback = ::std::option::Option<
8180 unsafe extern "C" fn(
8181 ch: PhidgetMotorPositionControllerHandle,
8182 ctx: *mut ::std::os::raw::c_void,
8183 dutyCycle: f64,
8184 ),
8185>;
8186extern "C" {
8187 pub fn PhidgetMotorPositionController_setOnDutyCycleUpdateHandler(
8188 ch: PhidgetMotorPositionControllerHandle,
8189 fptr: PhidgetMotorPositionController_OnDutyCycleUpdateCallback,
8190 ctx: *mut ::std::os::raw::c_void,
8191 ) -> PhidgetReturnCode;
8192}
8193pub type PhidgetMotorPositionController_OnExpectedPositionChangeCallback = ::std::option::Option<
8194 unsafe extern "C" fn(
8195 ch: PhidgetMotorPositionControllerHandle,
8196 ctx: *mut ::std::os::raw::c_void,
8197 expectedPosition: f64,
8198 ),
8199>;
8200extern "C" {
8201 pub fn PhidgetMotorPositionController_setOnExpectedPositionChangeHandler(
8202 ch: PhidgetMotorPositionControllerHandle,
8203 fptr: PhidgetMotorPositionController_OnExpectedPositionChangeCallback,
8204 ctx: *mut ::std::os::raw::c_void,
8205 ) -> PhidgetReturnCode;
8206}
8207pub type PhidgetMotorPositionController_OnPositionChangeCallback = ::std::option::Option<
8208 unsafe extern "C" fn(
8209 ch: PhidgetMotorPositionControllerHandle,
8210 ctx: *mut ::std::os::raw::c_void,
8211 position: f64,
8212 ),
8213>;
8214extern "C" {
8215 pub fn PhidgetMotorPositionController_setOnPositionChangeHandler(
8216 ch: PhidgetMotorPositionControllerHandle,
8217 fptr: PhidgetMotorPositionController_OnPositionChangeCallback,
8218 ctx: *mut ::std::os::raw::c_void,
8219 ) -> PhidgetReturnCode;
8220}
8221#[repr(C)]
8222#[derive(Debug, Copy, Clone)]
8223pub struct _PhidgetMotorVelocityController {
8224 _unused: [u8; 0],
8225}
8226pub type PhidgetMotorVelocityControllerHandle = *mut _PhidgetMotorVelocityController;
8227extern "C" {
8228 pub fn PhidgetMotorVelocityController_create(
8229 ch: *mut PhidgetMotorVelocityControllerHandle,
8230 ) -> PhidgetReturnCode;
8231}
8232extern "C" {
8233 pub fn PhidgetMotorVelocityController_delete(
8234 ch: *mut PhidgetMotorVelocityControllerHandle,
8235 ) -> PhidgetReturnCode;
8236}
8237extern "C" {
8238 pub fn PhidgetMotorVelocityController_enableFailsafe(
8239 ch: PhidgetMotorVelocityControllerHandle,
8240 failsafeTime: u32,
8241 ) -> PhidgetReturnCode;
8242}
8243extern "C" {
8244 pub fn PhidgetMotorVelocityController_resetFailsafe(
8245 ch: PhidgetMotorVelocityControllerHandle,
8246 ) -> PhidgetReturnCode;
8247}
8248extern "C" {
8249 pub fn PhidgetMotorVelocityController_setAcceleration(
8250 ch: PhidgetMotorVelocityControllerHandle,
8251 acceleration: f64,
8252 ) -> PhidgetReturnCode;
8253}
8254extern "C" {
8255 pub fn PhidgetMotorVelocityController_getAcceleration(
8256 ch: PhidgetMotorVelocityControllerHandle,
8257 acceleration: *mut f64,
8258 ) -> PhidgetReturnCode;
8259}
8260extern "C" {
8261 pub fn PhidgetMotorVelocityController_getMinAcceleration(
8262 ch: PhidgetMotorVelocityControllerHandle,
8263 minAcceleration: *mut f64,
8264 ) -> PhidgetReturnCode;
8265}
8266extern "C" {
8267 pub fn PhidgetMotorVelocityController_getMaxAcceleration(
8268 ch: PhidgetMotorVelocityControllerHandle,
8269 maxAcceleration: *mut f64,
8270 ) -> PhidgetReturnCode;
8271}
8272extern "C" {
8273 pub fn PhidgetMotorVelocityController_getActiveCurrentLimit(
8274 ch: PhidgetMotorVelocityControllerHandle,
8275 activeCurrentLimit: *mut f64,
8276 ) -> PhidgetReturnCode;
8277}
8278extern "C" {
8279 pub fn PhidgetMotorVelocityController_setCurrentLimit(
8280 ch: PhidgetMotorVelocityControllerHandle,
8281 currentLimit: f64,
8282 ) -> PhidgetReturnCode;
8283}
8284extern "C" {
8285 pub fn PhidgetMotorVelocityController_getCurrentLimit(
8286 ch: PhidgetMotorVelocityControllerHandle,
8287 currentLimit: *mut f64,
8288 ) -> PhidgetReturnCode;
8289}
8290extern "C" {
8291 pub fn PhidgetMotorVelocityController_getMinCurrentLimit(
8292 ch: PhidgetMotorVelocityControllerHandle,
8293 minCurrentLimit: *mut f64,
8294 ) -> PhidgetReturnCode;
8295}
8296extern "C" {
8297 pub fn PhidgetMotorVelocityController_getMaxCurrentLimit(
8298 ch: PhidgetMotorVelocityControllerHandle,
8299 maxCurrentLimit: *mut f64,
8300 ) -> PhidgetReturnCode;
8301}
8302extern "C" {
8303 pub fn PhidgetMotorVelocityController_setDataInterval(
8304 ch: PhidgetMotorVelocityControllerHandle,
8305 dataInterval: u32,
8306 ) -> PhidgetReturnCode;
8307}
8308extern "C" {
8309 pub fn PhidgetMotorVelocityController_getDataInterval(
8310 ch: PhidgetMotorVelocityControllerHandle,
8311 dataInterval: *mut u32,
8312 ) -> PhidgetReturnCode;
8313}
8314extern "C" {
8315 pub fn PhidgetMotorVelocityController_getMinDataInterval(
8316 ch: PhidgetMotorVelocityControllerHandle,
8317 minDataInterval: *mut u32,
8318 ) -> PhidgetReturnCode;
8319}
8320extern "C" {
8321 pub fn PhidgetMotorVelocityController_getMaxDataInterval(
8322 ch: PhidgetMotorVelocityControllerHandle,
8323 maxDataInterval: *mut u32,
8324 ) -> PhidgetReturnCode;
8325}
8326extern "C" {
8327 pub fn PhidgetMotorVelocityController_setDataRate(
8328 ch: PhidgetMotorVelocityControllerHandle,
8329 dataRate: f64,
8330 ) -> PhidgetReturnCode;
8331}
8332extern "C" {
8333 pub fn PhidgetMotorVelocityController_getDataRate(
8334 ch: PhidgetMotorVelocityControllerHandle,
8335 dataRate: *mut f64,
8336 ) -> PhidgetReturnCode;
8337}
8338extern "C" {
8339 pub fn PhidgetMotorVelocityController_getMinDataRate(
8340 ch: PhidgetMotorVelocityControllerHandle,
8341 minDataRate: *mut f64,
8342 ) -> PhidgetReturnCode;
8343}
8344extern "C" {
8345 pub fn PhidgetMotorVelocityController_getMaxDataRate(
8346 ch: PhidgetMotorVelocityControllerHandle,
8347 maxDataRate: *mut f64,
8348 ) -> PhidgetReturnCode;
8349}
8350extern "C" {
8351 pub fn PhidgetMotorVelocityController_setDeadBand(
8352 ch: PhidgetMotorVelocityControllerHandle,
8353 deadBand: f64,
8354 ) -> PhidgetReturnCode;
8355}
8356extern "C" {
8357 pub fn PhidgetMotorVelocityController_getDeadBand(
8358 ch: PhidgetMotorVelocityControllerHandle,
8359 deadBand: *mut f64,
8360 ) -> PhidgetReturnCode;
8361}
8362extern "C" {
8363 pub fn PhidgetMotorVelocityController_getDutyCycle(
8364 ch: PhidgetMotorVelocityControllerHandle,
8365 dutyCycle: *mut f64,
8366 ) -> PhidgetReturnCode;
8367}
8368extern "C" {
8369 pub fn PhidgetMotorVelocityController_setEngaged(
8370 ch: PhidgetMotorVelocityControllerHandle,
8371 engaged: ::std::os::raw::c_int,
8372 ) -> PhidgetReturnCode;
8373}
8374extern "C" {
8375 pub fn PhidgetMotorVelocityController_getEngaged(
8376 ch: PhidgetMotorVelocityControllerHandle,
8377 engaged: *mut ::std::os::raw::c_int,
8378 ) -> PhidgetReturnCode;
8379}
8380extern "C" {
8381 pub fn PhidgetMotorVelocityController_getExpectedVelocity(
8382 ch: PhidgetMotorVelocityControllerHandle,
8383 expectedVelocity: *mut f64,
8384 ) -> PhidgetReturnCode;
8385}
8386extern "C" {
8387 pub fn PhidgetMotorVelocityController_setEnableExpectedVelocity(
8388 ch: PhidgetMotorVelocityControllerHandle,
8389 enableExpectedVelocity: ::std::os::raw::c_int,
8390 ) -> PhidgetReturnCode;
8391}
8392extern "C" {
8393 pub fn PhidgetMotorVelocityController_getEnableExpectedVelocity(
8394 ch: PhidgetMotorVelocityControllerHandle,
8395 enableExpectedVelocity: *mut ::std::os::raw::c_int,
8396 ) -> PhidgetReturnCode;
8397}
8398extern "C" {
8399 pub fn PhidgetMotorVelocityController_setFailsafeBrakingEnabled(
8400 ch: PhidgetMotorVelocityControllerHandle,
8401 failsafeBrakingEnabled: ::std::os::raw::c_int,
8402 ) -> PhidgetReturnCode;
8403}
8404extern "C" {
8405 pub fn PhidgetMotorVelocityController_getFailsafeBrakingEnabled(
8406 ch: PhidgetMotorVelocityControllerHandle,
8407 failsafeBrakingEnabled: *mut ::std::os::raw::c_int,
8408 ) -> PhidgetReturnCode;
8409}
8410extern "C" {
8411 pub fn PhidgetMotorVelocityController_setFailsafeCurrentLimit(
8412 ch: PhidgetMotorVelocityControllerHandle,
8413 failsafeCurrentLimit: f64,
8414 ) -> PhidgetReturnCode;
8415}
8416extern "C" {
8417 pub fn PhidgetMotorVelocityController_getFailsafeCurrentLimit(
8418 ch: PhidgetMotorVelocityControllerHandle,
8419 failsafeCurrentLimit: *mut f64,
8420 ) -> PhidgetReturnCode;
8421}
8422extern "C" {
8423 pub fn PhidgetMotorVelocityController_getMinFailsafeTime(
8424 ch: PhidgetMotorVelocityControllerHandle,
8425 minFailsafeTime: *mut u32,
8426 ) -> PhidgetReturnCode;
8427}
8428extern "C" {
8429 pub fn PhidgetMotorVelocityController_getMaxFailsafeTime(
8430 ch: PhidgetMotorVelocityControllerHandle,
8431 maxFailsafeTime: *mut u32,
8432 ) -> PhidgetReturnCode;
8433}
8434extern "C" {
8435 pub fn PhidgetMotorVelocityController_setInductance(
8436 ch: PhidgetMotorVelocityControllerHandle,
8437 inductance: f64,
8438 ) -> PhidgetReturnCode;
8439}
8440extern "C" {
8441 pub fn PhidgetMotorVelocityController_getInductance(
8442 ch: PhidgetMotorVelocityControllerHandle,
8443 inductance: *mut f64,
8444 ) -> PhidgetReturnCode;
8445}
8446extern "C" {
8447 pub fn PhidgetMotorVelocityController_getMinInductance(
8448 ch: PhidgetMotorVelocityControllerHandle,
8449 minInductance: *mut f64,
8450 ) -> PhidgetReturnCode;
8451}
8452extern "C" {
8453 pub fn PhidgetMotorVelocityController_getMaxInductance(
8454 ch: PhidgetMotorVelocityControllerHandle,
8455 maxInductance: *mut f64,
8456 ) -> PhidgetReturnCode;
8457}
8458extern "C" {
8459 pub fn PhidgetMotorVelocityController_setKd(
8460 ch: PhidgetMotorVelocityControllerHandle,
8461 kd: f64,
8462 ) -> PhidgetReturnCode;
8463}
8464extern "C" {
8465 pub fn PhidgetMotorVelocityController_getKd(
8466 ch: PhidgetMotorVelocityControllerHandle,
8467 kd: *mut f64,
8468 ) -> PhidgetReturnCode;
8469}
8470extern "C" {
8471 pub fn PhidgetMotorVelocityController_setKi(
8472 ch: PhidgetMotorVelocityControllerHandle,
8473 ki: f64,
8474 ) -> PhidgetReturnCode;
8475}
8476extern "C" {
8477 pub fn PhidgetMotorVelocityController_getKi(
8478 ch: PhidgetMotorVelocityControllerHandle,
8479 ki: *mut f64,
8480 ) -> PhidgetReturnCode;
8481}
8482extern "C" {
8483 pub fn PhidgetMotorVelocityController_setKp(
8484 ch: PhidgetMotorVelocityControllerHandle,
8485 kp: f64,
8486 ) -> PhidgetReturnCode;
8487}
8488extern "C" {
8489 pub fn PhidgetMotorVelocityController_getKp(
8490 ch: PhidgetMotorVelocityControllerHandle,
8491 kp: *mut f64,
8492 ) -> PhidgetReturnCode;
8493}
8494extern "C" {
8495 pub fn PhidgetMotorVelocityController_setPositionType(
8496 ch: PhidgetMotorVelocityControllerHandle,
8497 positionType: Phidget_PositionType,
8498 ) -> PhidgetReturnCode;
8499}
8500extern "C" {
8501 pub fn PhidgetMotorVelocityController_getPositionType(
8502 ch: PhidgetMotorVelocityControllerHandle,
8503 positionType: *mut Phidget_PositionType,
8504 ) -> PhidgetReturnCode;
8505}
8506extern "C" {
8507 pub fn PhidgetMotorVelocityController_setRescaleFactor(
8508 ch: PhidgetMotorVelocityControllerHandle,
8509 rescaleFactor: f64,
8510 ) -> PhidgetReturnCode;
8511}
8512extern "C" {
8513 pub fn PhidgetMotorVelocityController_getRescaleFactor(
8514 ch: PhidgetMotorVelocityControllerHandle,
8515 rescaleFactor: *mut f64,
8516 ) -> PhidgetReturnCode;
8517}
8518extern "C" {
8519 pub fn PhidgetMotorVelocityController_setStallVelocity(
8520 ch: PhidgetMotorVelocityControllerHandle,
8521 stallVelocity: f64,
8522 ) -> PhidgetReturnCode;
8523}
8524extern "C" {
8525 pub fn PhidgetMotorVelocityController_getStallVelocity(
8526 ch: PhidgetMotorVelocityControllerHandle,
8527 stallVelocity: *mut f64,
8528 ) -> PhidgetReturnCode;
8529}
8530extern "C" {
8531 pub fn PhidgetMotorVelocityController_getMinStallVelocity(
8532 ch: PhidgetMotorVelocityControllerHandle,
8533 minStallVelocity: *mut f64,
8534 ) -> PhidgetReturnCode;
8535}
8536extern "C" {
8537 pub fn PhidgetMotorVelocityController_getMaxStallVelocity(
8538 ch: PhidgetMotorVelocityControllerHandle,
8539 maxStallVelocity: *mut f64,
8540 ) -> PhidgetReturnCode;
8541}
8542extern "C" {
8543 pub fn PhidgetMotorVelocityController_setSurgeCurrentLimit(
8544 ch: PhidgetMotorVelocityControllerHandle,
8545 surgeCurrentLimit: f64,
8546 ) -> PhidgetReturnCode;
8547}
8548extern "C" {
8549 pub fn PhidgetMotorVelocityController_getSurgeCurrentLimit(
8550 ch: PhidgetMotorVelocityControllerHandle,
8551 surgeCurrentLimit: *mut f64,
8552 ) -> PhidgetReturnCode;
8553}
8554extern "C" {
8555 pub fn PhidgetMotorVelocityController_getMinSurgeCurrentLimit(
8556 ch: PhidgetMotorVelocityControllerHandle,
8557 minSurgeCurrentLimit: *mut f64,
8558 ) -> PhidgetReturnCode;
8559}
8560extern "C" {
8561 pub fn PhidgetMotorVelocityController_getMaxSurgeCurrentLimit(
8562 ch: PhidgetMotorVelocityControllerHandle,
8563 maxSurgeCurrentLimit: *mut f64,
8564 ) -> PhidgetReturnCode;
8565}
8566extern "C" {
8567 pub fn PhidgetMotorVelocityController_setTargetVelocity(
8568 ch: PhidgetMotorVelocityControllerHandle,
8569 targetVelocity: f64,
8570 ) -> PhidgetReturnCode;
8571}
8572extern "C" {
8573 pub fn PhidgetMotorVelocityController_getTargetVelocity(
8574 ch: PhidgetMotorVelocityControllerHandle,
8575 targetVelocity: *mut f64,
8576 ) -> PhidgetReturnCode;
8577}
8578extern "C" {
8579 pub fn PhidgetMotorVelocityController_getMinTargetVelocity(
8580 ch: PhidgetMotorVelocityControllerHandle,
8581 minTargetVelocity: *mut f64,
8582 ) -> PhidgetReturnCode;
8583}
8584extern "C" {
8585 pub fn PhidgetMotorVelocityController_getMaxTargetVelocity(
8586 ch: PhidgetMotorVelocityControllerHandle,
8587 maxTargetVelocity: *mut f64,
8588 ) -> PhidgetReturnCode;
8589}
8590extern "C" {
8591 pub fn PhidgetMotorVelocityController_getVelocity(
8592 ch: PhidgetMotorVelocityControllerHandle,
8593 velocity: *mut f64,
8594 ) -> PhidgetReturnCode;
8595}
8596pub type PhidgetMotorVelocityController_OnDutyCycleUpdateCallback = ::std::option::Option<
8597 unsafe extern "C" fn(
8598 ch: PhidgetMotorVelocityControllerHandle,
8599 ctx: *mut ::std::os::raw::c_void,
8600 dutyCycle: f64,
8601 ),
8602>;
8603extern "C" {
8604 pub fn PhidgetMotorVelocityController_setOnDutyCycleUpdateHandler(
8605 ch: PhidgetMotorVelocityControllerHandle,
8606 fptr: PhidgetMotorVelocityController_OnDutyCycleUpdateCallback,
8607 ctx: *mut ::std::os::raw::c_void,
8608 ) -> PhidgetReturnCode;
8609}
8610pub type PhidgetMotorVelocityController_OnExpectedVelocityChangeCallback = ::std::option::Option<
8611 unsafe extern "C" fn(
8612 ch: PhidgetMotorVelocityControllerHandle,
8613 ctx: *mut ::std::os::raw::c_void,
8614 expectedVelocity: f64,
8615 ),
8616>;
8617extern "C" {
8618 pub fn PhidgetMotorVelocityController_setOnExpectedVelocityChangeHandler(
8619 ch: PhidgetMotorVelocityControllerHandle,
8620 fptr: PhidgetMotorVelocityController_OnExpectedVelocityChangeCallback,
8621 ctx: *mut ::std::os::raw::c_void,
8622 ) -> PhidgetReturnCode;
8623}
8624pub type PhidgetMotorVelocityController_OnVelocityChangeCallback = ::std::option::Option<
8625 unsafe extern "C" fn(
8626 ch: PhidgetMotorVelocityControllerHandle,
8627 ctx: *mut ::std::os::raw::c_void,
8628 velocity: f64,
8629 ),
8630>;
8631extern "C" {
8632 pub fn PhidgetMotorVelocityController_setOnVelocityChangeHandler(
8633 ch: PhidgetMotorVelocityControllerHandle,
8634 fptr: PhidgetMotorVelocityController_OnVelocityChangeCallback,
8635 ctx: *mut ::std::os::raw::c_void,
8636 ) -> PhidgetReturnCode;
8637}
8638#[repr(C)]
8639#[derive(Debug, Copy, Clone)]
8640pub struct _PhidgetPHSensor {
8641 _unused: [u8; 0],
8642}
8643pub type PhidgetPHSensorHandle = *mut _PhidgetPHSensor;
8644extern "C" {
8645 pub fn PhidgetPHSensor_create(ch: *mut PhidgetPHSensorHandle) -> PhidgetReturnCode;
8646}
8647extern "C" {
8648 pub fn PhidgetPHSensor_delete(ch: *mut PhidgetPHSensorHandle) -> PhidgetReturnCode;
8649}
8650extern "C" {
8651 pub fn PhidgetPHSensor_setCorrectionTemperature(
8652 ch: PhidgetPHSensorHandle,
8653 correctionTemperature: f64,
8654 ) -> PhidgetReturnCode;
8655}
8656extern "C" {
8657 pub fn PhidgetPHSensor_getCorrectionTemperature(
8658 ch: PhidgetPHSensorHandle,
8659 correctionTemperature: *mut f64,
8660 ) -> PhidgetReturnCode;
8661}
8662extern "C" {
8663 pub fn PhidgetPHSensor_getMinCorrectionTemperature(
8664 ch: PhidgetPHSensorHandle,
8665 minCorrectionTemperature: *mut f64,
8666 ) -> PhidgetReturnCode;
8667}
8668extern "C" {
8669 pub fn PhidgetPHSensor_getMaxCorrectionTemperature(
8670 ch: PhidgetPHSensorHandle,
8671 maxCorrectionTemperature: *mut f64,
8672 ) -> PhidgetReturnCode;
8673}
8674extern "C" {
8675 pub fn PhidgetPHSensor_setDataInterval(
8676 ch: PhidgetPHSensorHandle,
8677 dataInterval: u32,
8678 ) -> PhidgetReturnCode;
8679}
8680extern "C" {
8681 pub fn PhidgetPHSensor_getDataInterval(
8682 ch: PhidgetPHSensorHandle,
8683 dataInterval: *mut u32,
8684 ) -> PhidgetReturnCode;
8685}
8686extern "C" {
8687 pub fn PhidgetPHSensor_getMinDataInterval(
8688 ch: PhidgetPHSensorHandle,
8689 minDataInterval: *mut u32,
8690 ) -> PhidgetReturnCode;
8691}
8692extern "C" {
8693 pub fn PhidgetPHSensor_getMaxDataInterval(
8694 ch: PhidgetPHSensorHandle,
8695 maxDataInterval: *mut u32,
8696 ) -> PhidgetReturnCode;
8697}
8698extern "C" {
8699 pub fn PhidgetPHSensor_setDataRate(
8700 ch: PhidgetPHSensorHandle,
8701 dataRate: f64,
8702 ) -> PhidgetReturnCode;
8703}
8704extern "C" {
8705 pub fn PhidgetPHSensor_getDataRate(
8706 ch: PhidgetPHSensorHandle,
8707 dataRate: *mut f64,
8708 ) -> PhidgetReturnCode;
8709}
8710extern "C" {
8711 pub fn PhidgetPHSensor_getMinDataRate(
8712 ch: PhidgetPHSensorHandle,
8713 minDataRate: *mut f64,
8714 ) -> PhidgetReturnCode;
8715}
8716extern "C" {
8717 pub fn PhidgetPHSensor_getMaxDataRate(
8718 ch: PhidgetPHSensorHandle,
8719 maxDataRate: *mut f64,
8720 ) -> PhidgetReturnCode;
8721}
8722extern "C" {
8723 pub fn PhidgetPHSensor_getPH(ch: PhidgetPHSensorHandle, PH: *mut f64) -> PhidgetReturnCode;
8724}
8725extern "C" {
8726 pub fn PhidgetPHSensor_getMinPH(
8727 ch: PhidgetPHSensorHandle,
8728 minPH: *mut f64,
8729 ) -> PhidgetReturnCode;
8730}
8731extern "C" {
8732 pub fn PhidgetPHSensor_getMaxPH(
8733 ch: PhidgetPHSensorHandle,
8734 maxPH: *mut f64,
8735 ) -> PhidgetReturnCode;
8736}
8737extern "C" {
8738 pub fn PhidgetPHSensor_setPHChangeTrigger(
8739 ch: PhidgetPHSensorHandle,
8740 PHChangeTrigger: f64,
8741 ) -> PhidgetReturnCode;
8742}
8743extern "C" {
8744 pub fn PhidgetPHSensor_getPHChangeTrigger(
8745 ch: PhidgetPHSensorHandle,
8746 PHChangeTrigger: *mut f64,
8747 ) -> PhidgetReturnCode;
8748}
8749extern "C" {
8750 pub fn PhidgetPHSensor_getMinPHChangeTrigger(
8751 ch: PhidgetPHSensorHandle,
8752 minPHChangeTrigger: *mut f64,
8753 ) -> PhidgetReturnCode;
8754}
8755extern "C" {
8756 pub fn PhidgetPHSensor_getMaxPHChangeTrigger(
8757 ch: PhidgetPHSensorHandle,
8758 maxPHChangeTrigger: *mut f64,
8759 ) -> PhidgetReturnCode;
8760}
8761pub type PhidgetPHSensor_OnPHChangeCallback = ::std::option::Option<
8762 unsafe extern "C" fn(ch: PhidgetPHSensorHandle, ctx: *mut ::std::os::raw::c_void, PH: f64),
8763>;
8764extern "C" {
8765 pub fn PhidgetPHSensor_setOnPHChangeHandler(
8766 ch: PhidgetPHSensorHandle,
8767 fptr: PhidgetPHSensor_OnPHChangeCallback,
8768 ctx: *mut ::std::os::raw::c_void,
8769 ) -> PhidgetReturnCode;
8770}
8771#[repr(C)]
8772#[derive(Debug, Copy, Clone)]
8773pub struct _PhidgetPowerGuard {
8774 _unused: [u8; 0],
8775}
8776pub type PhidgetPowerGuardHandle = *mut _PhidgetPowerGuard;
8777extern "C" {
8778 pub fn PhidgetPowerGuard_create(ch: *mut PhidgetPowerGuardHandle) -> PhidgetReturnCode;
8779}
8780extern "C" {
8781 pub fn PhidgetPowerGuard_delete(ch: *mut PhidgetPowerGuardHandle) -> PhidgetReturnCode;
8782}
8783extern "C" {
8784 pub fn PhidgetPowerGuard_enableFailsafe(
8785 ch: PhidgetPowerGuardHandle,
8786 failsafeTime: u32,
8787 ) -> PhidgetReturnCode;
8788}
8789extern "C" {
8790 pub fn PhidgetPowerGuard_resetFailsafe(ch: PhidgetPowerGuardHandle) -> PhidgetReturnCode;
8791}
8792extern "C" {
8793 pub fn PhidgetPowerGuard_getMinFailsafeTime(
8794 ch: PhidgetPowerGuardHandle,
8795 minFailsafeTime: *mut u32,
8796 ) -> PhidgetReturnCode;
8797}
8798extern "C" {
8799 pub fn PhidgetPowerGuard_getMaxFailsafeTime(
8800 ch: PhidgetPowerGuardHandle,
8801 maxFailsafeTime: *mut u32,
8802 ) -> PhidgetReturnCode;
8803}
8804extern "C" {
8805 pub fn PhidgetPowerGuard_setFanMode(
8806 ch: PhidgetPowerGuardHandle,
8807 fanMode: Phidget_FanMode,
8808 ) -> PhidgetReturnCode;
8809}
8810extern "C" {
8811 pub fn PhidgetPowerGuard_getFanMode(
8812 ch: PhidgetPowerGuardHandle,
8813 fanMode: *mut Phidget_FanMode,
8814 ) -> PhidgetReturnCode;
8815}
8816extern "C" {
8817 pub fn PhidgetPowerGuard_setOverVoltage(
8818 ch: PhidgetPowerGuardHandle,
8819 overVoltage: f64,
8820 ) -> PhidgetReturnCode;
8821}
8822extern "C" {
8823 pub fn PhidgetPowerGuard_getOverVoltage(
8824 ch: PhidgetPowerGuardHandle,
8825 overVoltage: *mut f64,
8826 ) -> PhidgetReturnCode;
8827}
8828extern "C" {
8829 pub fn PhidgetPowerGuard_getMinOverVoltage(
8830 ch: PhidgetPowerGuardHandle,
8831 minOverVoltage: *mut f64,
8832 ) -> PhidgetReturnCode;
8833}
8834extern "C" {
8835 pub fn PhidgetPowerGuard_getMaxOverVoltage(
8836 ch: PhidgetPowerGuardHandle,
8837 maxOverVoltage: *mut f64,
8838 ) -> PhidgetReturnCode;
8839}
8840extern "C" {
8841 pub fn PhidgetPowerGuard_setPowerEnabled(
8842 ch: PhidgetPowerGuardHandle,
8843 powerEnabled: ::std::os::raw::c_int,
8844 ) -> PhidgetReturnCode;
8845}
8846extern "C" {
8847 pub fn PhidgetPowerGuard_getPowerEnabled(
8848 ch: PhidgetPowerGuardHandle,
8849 powerEnabled: *mut ::std::os::raw::c_int,
8850 ) -> PhidgetReturnCode;
8851}
8852#[repr(C)]
8853#[derive(Debug, Copy, Clone)]
8854pub struct _PhidgetPressureSensor {
8855 _unused: [u8; 0],
8856}
8857pub type PhidgetPressureSensorHandle = *mut _PhidgetPressureSensor;
8858extern "C" {
8859 pub fn PhidgetPressureSensor_create(ch: *mut PhidgetPressureSensorHandle) -> PhidgetReturnCode;
8860}
8861extern "C" {
8862 pub fn PhidgetPressureSensor_delete(ch: *mut PhidgetPressureSensorHandle) -> PhidgetReturnCode;
8863}
8864extern "C" {
8865 pub fn PhidgetPressureSensor_setDataInterval(
8866 ch: PhidgetPressureSensorHandle,
8867 dataInterval: u32,
8868 ) -> PhidgetReturnCode;
8869}
8870extern "C" {
8871 pub fn PhidgetPressureSensor_getDataInterval(
8872 ch: PhidgetPressureSensorHandle,
8873 dataInterval: *mut u32,
8874 ) -> PhidgetReturnCode;
8875}
8876extern "C" {
8877 pub fn PhidgetPressureSensor_getMinDataInterval(
8878 ch: PhidgetPressureSensorHandle,
8879 minDataInterval: *mut u32,
8880 ) -> PhidgetReturnCode;
8881}
8882extern "C" {
8883 pub fn PhidgetPressureSensor_getMaxDataInterval(
8884 ch: PhidgetPressureSensorHandle,
8885 maxDataInterval: *mut u32,
8886 ) -> PhidgetReturnCode;
8887}
8888extern "C" {
8889 pub fn PhidgetPressureSensor_setDataRate(
8890 ch: PhidgetPressureSensorHandle,
8891 dataRate: f64,
8892 ) -> PhidgetReturnCode;
8893}
8894extern "C" {
8895 pub fn PhidgetPressureSensor_getDataRate(
8896 ch: PhidgetPressureSensorHandle,
8897 dataRate: *mut f64,
8898 ) -> PhidgetReturnCode;
8899}
8900extern "C" {
8901 pub fn PhidgetPressureSensor_getMinDataRate(
8902 ch: PhidgetPressureSensorHandle,
8903 minDataRate: *mut f64,
8904 ) -> PhidgetReturnCode;
8905}
8906extern "C" {
8907 pub fn PhidgetPressureSensor_getMaxDataRate(
8908 ch: PhidgetPressureSensorHandle,
8909 maxDataRate: *mut f64,
8910 ) -> PhidgetReturnCode;
8911}
8912extern "C" {
8913 pub fn PhidgetPressureSensor_getPressure(
8914 ch: PhidgetPressureSensorHandle,
8915 pressure: *mut f64,
8916 ) -> PhidgetReturnCode;
8917}
8918extern "C" {
8919 pub fn PhidgetPressureSensor_getMinPressure(
8920 ch: PhidgetPressureSensorHandle,
8921 minPressure: *mut f64,
8922 ) -> PhidgetReturnCode;
8923}
8924extern "C" {
8925 pub fn PhidgetPressureSensor_getMaxPressure(
8926 ch: PhidgetPressureSensorHandle,
8927 maxPressure: *mut f64,
8928 ) -> PhidgetReturnCode;
8929}
8930extern "C" {
8931 pub fn PhidgetPressureSensor_setPressureChangeTrigger(
8932 ch: PhidgetPressureSensorHandle,
8933 pressureChangeTrigger: f64,
8934 ) -> PhidgetReturnCode;
8935}
8936extern "C" {
8937 pub fn PhidgetPressureSensor_getPressureChangeTrigger(
8938 ch: PhidgetPressureSensorHandle,
8939 pressureChangeTrigger: *mut f64,
8940 ) -> PhidgetReturnCode;
8941}
8942extern "C" {
8943 pub fn PhidgetPressureSensor_getMinPressureChangeTrigger(
8944 ch: PhidgetPressureSensorHandle,
8945 minPressureChangeTrigger: *mut f64,
8946 ) -> PhidgetReturnCode;
8947}
8948extern "C" {
8949 pub fn PhidgetPressureSensor_getMaxPressureChangeTrigger(
8950 ch: PhidgetPressureSensorHandle,
8951 maxPressureChangeTrigger: *mut f64,
8952 ) -> PhidgetReturnCode;
8953}
8954pub type PhidgetPressureSensor_OnPressureChangeCallback = ::std::option::Option<
8955 unsafe extern "C" fn(
8956 ch: PhidgetPressureSensorHandle,
8957 ctx: *mut ::std::os::raw::c_void,
8958 pressure: f64,
8959 ),
8960>;
8961extern "C" {
8962 pub fn PhidgetPressureSensor_setOnPressureChangeHandler(
8963 ch: PhidgetPressureSensorHandle,
8964 fptr: PhidgetPressureSensor_OnPressureChangeCallback,
8965 ctx: *mut ::std::os::raw::c_void,
8966 ) -> PhidgetReturnCode;
8967}
8968#[repr(C)]
8969#[derive(Debug, Copy, Clone)]
8970pub struct _PhidgetRCServo {
8971 _unused: [u8; 0],
8972}
8973pub type PhidgetRCServoHandle = *mut _PhidgetRCServo;
8974extern "C" {
8975 pub fn PhidgetRCServo_create(ch: *mut PhidgetRCServoHandle) -> PhidgetReturnCode;
8976}
8977extern "C" {
8978 pub fn PhidgetRCServo_delete(ch: *mut PhidgetRCServoHandle) -> PhidgetReturnCode;
8979}
8980extern "C" {
8981 pub fn PhidgetRCServo_enableFailsafe(
8982 ch: PhidgetRCServoHandle,
8983 failsafeTime: u32,
8984 ) -> PhidgetReturnCode;
8985}
8986extern "C" {
8987 pub fn PhidgetRCServo_resetFailsafe(ch: PhidgetRCServoHandle) -> PhidgetReturnCode;
8988}
8989extern "C" {
8990 pub fn PhidgetRCServo_setAcceleration(
8991 ch: PhidgetRCServoHandle,
8992 acceleration: f64,
8993 ) -> PhidgetReturnCode;
8994}
8995extern "C" {
8996 pub fn PhidgetRCServo_getAcceleration(
8997 ch: PhidgetRCServoHandle,
8998 acceleration: *mut f64,
8999 ) -> PhidgetReturnCode;
9000}
9001extern "C" {
9002 pub fn PhidgetRCServo_getMinAcceleration(
9003 ch: PhidgetRCServoHandle,
9004 minAcceleration: *mut f64,
9005 ) -> PhidgetReturnCode;
9006}
9007extern "C" {
9008 pub fn PhidgetRCServo_getMaxAcceleration(
9009 ch: PhidgetRCServoHandle,
9010 maxAcceleration: *mut f64,
9011 ) -> PhidgetReturnCode;
9012}
9013extern "C" {
9014 pub fn PhidgetRCServo_setDataInterval(
9015 ch: PhidgetRCServoHandle,
9016 dataInterval: u32,
9017 ) -> PhidgetReturnCode;
9018}
9019extern "C" {
9020 pub fn PhidgetRCServo_getDataInterval(
9021 ch: PhidgetRCServoHandle,
9022 dataInterval: *mut u32,
9023 ) -> PhidgetReturnCode;
9024}
9025extern "C" {
9026 pub fn PhidgetRCServo_getMinDataInterval(
9027 ch: PhidgetRCServoHandle,
9028 minDataInterval: *mut u32,
9029 ) -> PhidgetReturnCode;
9030}
9031extern "C" {
9032 pub fn PhidgetRCServo_getMaxDataInterval(
9033 ch: PhidgetRCServoHandle,
9034 maxDataInterval: *mut u32,
9035 ) -> PhidgetReturnCode;
9036}
9037extern "C" {
9038 pub fn PhidgetRCServo_setDataRate(ch: PhidgetRCServoHandle, dataRate: f64)
9039 -> PhidgetReturnCode;
9040}
9041extern "C" {
9042 pub fn PhidgetRCServo_getDataRate(
9043 ch: PhidgetRCServoHandle,
9044 dataRate: *mut f64,
9045 ) -> PhidgetReturnCode;
9046}
9047extern "C" {
9048 pub fn PhidgetRCServo_getMinDataRate(
9049 ch: PhidgetRCServoHandle,
9050 minDataRate: *mut f64,
9051 ) -> PhidgetReturnCode;
9052}
9053extern "C" {
9054 pub fn PhidgetRCServo_getMaxDataRate(
9055 ch: PhidgetRCServoHandle,
9056 maxDataRate: *mut f64,
9057 ) -> PhidgetReturnCode;
9058}
9059extern "C" {
9060 pub fn PhidgetRCServo_setEngaged(
9061 ch: PhidgetRCServoHandle,
9062 engaged: ::std::os::raw::c_int,
9063 ) -> PhidgetReturnCode;
9064}
9065extern "C" {
9066 pub fn PhidgetRCServo_getEngaged(
9067 ch: PhidgetRCServoHandle,
9068 engaged: *mut ::std::os::raw::c_int,
9069 ) -> PhidgetReturnCode;
9070}
9071extern "C" {
9072 pub fn PhidgetRCServo_getMinFailsafeTime(
9073 ch: PhidgetRCServoHandle,
9074 minFailsafeTime: *mut u32,
9075 ) -> PhidgetReturnCode;
9076}
9077extern "C" {
9078 pub fn PhidgetRCServo_getMaxFailsafeTime(
9079 ch: PhidgetRCServoHandle,
9080 maxFailsafeTime: *mut u32,
9081 ) -> PhidgetReturnCode;
9082}
9083extern "C" {
9084 pub fn PhidgetRCServo_getIsMoving(
9085 ch: PhidgetRCServoHandle,
9086 isMoving: *mut ::std::os::raw::c_int,
9087 ) -> PhidgetReturnCode;
9088}
9089extern "C" {
9090 pub fn PhidgetRCServo_getPosition(
9091 ch: PhidgetRCServoHandle,
9092 position: *mut f64,
9093 ) -> PhidgetReturnCode;
9094}
9095extern "C" {
9096 pub fn PhidgetRCServo_setMinPosition(
9097 ch: PhidgetRCServoHandle,
9098 minPosition: f64,
9099 ) -> PhidgetReturnCode;
9100}
9101extern "C" {
9102 pub fn PhidgetRCServo_getMinPosition(
9103 ch: PhidgetRCServoHandle,
9104 minPosition: *mut f64,
9105 ) -> PhidgetReturnCode;
9106}
9107extern "C" {
9108 pub fn PhidgetRCServo_setMaxPosition(
9109 ch: PhidgetRCServoHandle,
9110 maxPosition: f64,
9111 ) -> PhidgetReturnCode;
9112}
9113extern "C" {
9114 pub fn PhidgetRCServo_getMaxPosition(
9115 ch: PhidgetRCServoHandle,
9116 maxPosition: *mut f64,
9117 ) -> PhidgetReturnCode;
9118}
9119extern "C" {
9120 pub fn PhidgetRCServo_setMinPulseWidth(
9121 ch: PhidgetRCServoHandle,
9122 minPulseWidth: f64,
9123 ) -> PhidgetReturnCode;
9124}
9125extern "C" {
9126 pub fn PhidgetRCServo_getMinPulseWidth(
9127 ch: PhidgetRCServoHandle,
9128 minPulseWidth: *mut f64,
9129 ) -> PhidgetReturnCode;
9130}
9131extern "C" {
9132 pub fn PhidgetRCServo_setMaxPulseWidth(
9133 ch: PhidgetRCServoHandle,
9134 maxPulseWidth: f64,
9135 ) -> PhidgetReturnCode;
9136}
9137extern "C" {
9138 pub fn PhidgetRCServo_getMaxPulseWidth(
9139 ch: PhidgetRCServoHandle,
9140 maxPulseWidth: *mut f64,
9141 ) -> PhidgetReturnCode;
9142}
9143extern "C" {
9144 pub fn PhidgetRCServo_getMinPulseWidthLimit(
9145 ch: PhidgetRCServoHandle,
9146 minPulseWidthLimit: *mut f64,
9147 ) -> PhidgetReturnCode;
9148}
9149extern "C" {
9150 pub fn PhidgetRCServo_getMaxPulseWidthLimit(
9151 ch: PhidgetRCServoHandle,
9152 maxPulseWidthLimit: *mut f64,
9153 ) -> PhidgetReturnCode;
9154}
9155extern "C" {
9156 pub fn PhidgetRCServo_setSpeedRampingState(
9157 ch: PhidgetRCServoHandle,
9158 speedRampingState: ::std::os::raw::c_int,
9159 ) -> PhidgetReturnCode;
9160}
9161extern "C" {
9162 pub fn PhidgetRCServo_getSpeedRampingState(
9163 ch: PhidgetRCServoHandle,
9164 speedRampingState: *mut ::std::os::raw::c_int,
9165 ) -> PhidgetReturnCode;
9166}
9167extern "C" {
9168 pub fn PhidgetRCServo_setTargetPosition(
9169 ch: PhidgetRCServoHandle,
9170 targetPosition: f64,
9171 ) -> PhidgetReturnCode;
9172}
9173extern "C" {
9174 pub fn PhidgetRCServo_setTargetPosition_async(
9175 ch: PhidgetRCServoHandle,
9176 targetPosition: f64,
9177 fptr: Phidget_AsyncCallback,
9178 ctx: *mut ::std::os::raw::c_void,
9179 );
9180}
9181extern "C" {
9182 pub fn PhidgetRCServo_getTargetPosition(
9183 ch: PhidgetRCServoHandle,
9184 targetPosition: *mut f64,
9185 ) -> PhidgetReturnCode;
9186}
9187extern "C" {
9188 pub fn PhidgetRCServo_setTorque(ch: PhidgetRCServoHandle, torque: f64) -> PhidgetReturnCode;
9189}
9190extern "C" {
9191 pub fn PhidgetRCServo_getTorque(
9192 ch: PhidgetRCServoHandle,
9193 torque: *mut f64,
9194 ) -> PhidgetReturnCode;
9195}
9196extern "C" {
9197 pub fn PhidgetRCServo_getMinTorque(
9198 ch: PhidgetRCServoHandle,
9199 minTorque: *mut f64,
9200 ) -> PhidgetReturnCode;
9201}
9202extern "C" {
9203 pub fn PhidgetRCServo_getMaxTorque(
9204 ch: PhidgetRCServoHandle,
9205 maxTorque: *mut f64,
9206 ) -> PhidgetReturnCode;
9207}
9208extern "C" {
9209 pub fn PhidgetRCServo_getVelocity(
9210 ch: PhidgetRCServoHandle,
9211 velocity: *mut f64,
9212 ) -> PhidgetReturnCode;
9213}
9214extern "C" {
9215 pub fn PhidgetRCServo_setVelocityLimit(
9216 ch: PhidgetRCServoHandle,
9217 velocityLimit: f64,
9218 ) -> PhidgetReturnCode;
9219}
9220extern "C" {
9221 pub fn PhidgetRCServo_getVelocityLimit(
9222 ch: PhidgetRCServoHandle,
9223 velocityLimit: *mut f64,
9224 ) -> PhidgetReturnCode;
9225}
9226extern "C" {
9227 pub fn PhidgetRCServo_getMinVelocityLimit(
9228 ch: PhidgetRCServoHandle,
9229 minVelocityLimit: *mut f64,
9230 ) -> PhidgetReturnCode;
9231}
9232extern "C" {
9233 pub fn PhidgetRCServo_getMaxVelocityLimit(
9234 ch: PhidgetRCServoHandle,
9235 maxVelocityLimit: *mut f64,
9236 ) -> PhidgetReturnCode;
9237}
9238extern "C" {
9239 pub fn PhidgetRCServo_setVoltage(
9240 ch: PhidgetRCServoHandle,
9241 voltage: PhidgetRCServo_Voltage,
9242 ) -> PhidgetReturnCode;
9243}
9244extern "C" {
9245 pub fn PhidgetRCServo_getVoltage(
9246 ch: PhidgetRCServoHandle,
9247 voltage: *mut PhidgetRCServo_Voltage,
9248 ) -> PhidgetReturnCode;
9249}
9250pub type PhidgetRCServo_OnPositionChangeCallback = ::std::option::Option<
9251 unsafe extern "C" fn(ch: PhidgetRCServoHandle, ctx: *mut ::std::os::raw::c_void, position: f64),
9252>;
9253extern "C" {
9254 pub fn PhidgetRCServo_setOnPositionChangeHandler(
9255 ch: PhidgetRCServoHandle,
9256 fptr: PhidgetRCServo_OnPositionChangeCallback,
9257 ctx: *mut ::std::os::raw::c_void,
9258 ) -> PhidgetReturnCode;
9259}
9260pub type PhidgetRCServo_OnTargetPositionReachedCallback = ::std::option::Option<
9261 unsafe extern "C" fn(ch: PhidgetRCServoHandle, ctx: *mut ::std::os::raw::c_void, position: f64),
9262>;
9263extern "C" {
9264 pub fn PhidgetRCServo_setOnTargetPositionReachedHandler(
9265 ch: PhidgetRCServoHandle,
9266 fptr: PhidgetRCServo_OnTargetPositionReachedCallback,
9267 ctx: *mut ::std::os::raw::c_void,
9268 ) -> PhidgetReturnCode;
9269}
9270pub type PhidgetRCServo_OnVelocityChangeCallback = ::std::option::Option<
9271 unsafe extern "C" fn(ch: PhidgetRCServoHandle, ctx: *mut ::std::os::raw::c_void, velocity: f64),
9272>;
9273extern "C" {
9274 pub fn PhidgetRCServo_setOnVelocityChangeHandler(
9275 ch: PhidgetRCServoHandle,
9276 fptr: PhidgetRCServo_OnVelocityChangeCallback,
9277 ctx: *mut ::std::os::raw::c_void,
9278 ) -> PhidgetReturnCode;
9279}
9280#[repr(C)]
9281#[derive(Debug, Copy, Clone)]
9282pub struct _PhidgetRFID {
9283 _unused: [u8; 0],
9284}
9285pub type PhidgetRFIDHandle = *mut _PhidgetRFID;
9286extern "C" {
9287 pub fn PhidgetRFID_create(ch: *mut PhidgetRFIDHandle) -> PhidgetReturnCode;
9288}
9289extern "C" {
9290 pub fn PhidgetRFID_delete(ch: *mut PhidgetRFIDHandle) -> PhidgetReturnCode;
9291}
9292extern "C" {
9293 pub fn PhidgetRFID_getLastTag(
9294 ch: PhidgetRFIDHandle,
9295 tagString: *mut ::std::os::raw::c_char,
9296 tagStringLen: usize,
9297 protocol: *mut PhidgetRFID_Protocol,
9298 ) -> PhidgetReturnCode;
9299}
9300extern "C" {
9301 pub fn PhidgetRFID_write(
9302 ch: PhidgetRFIDHandle,
9303 tagString: *const ::std::os::raw::c_char,
9304 protocol: PhidgetRFID_Protocol,
9305 lockTag: ::std::os::raw::c_int,
9306 ) -> PhidgetReturnCode;
9307}
9308extern "C" {
9309 pub fn PhidgetRFID_writeWithChipset(
9310 ch: PhidgetRFIDHandle,
9311 tagString: *const ::std::os::raw::c_char,
9312 protocol: PhidgetRFID_Protocol,
9313 lockTag: ::std::os::raw::c_int,
9314 chipset: PhidgetRFID_Chipset,
9315 ) -> PhidgetReturnCode;
9316}
9317extern "C" {
9318 pub fn PhidgetRFID_setAntennaEnabled(
9319 ch: PhidgetRFIDHandle,
9320 antennaEnabled: ::std::os::raw::c_int,
9321 ) -> PhidgetReturnCode;
9322}
9323extern "C" {
9324 pub fn PhidgetRFID_getAntennaEnabled(
9325 ch: PhidgetRFIDHandle,
9326 antennaEnabled: *mut ::std::os::raw::c_int,
9327 ) -> PhidgetReturnCode;
9328}
9329extern "C" {
9330 pub fn PhidgetRFID_getTagPresent(
9331 ch: PhidgetRFIDHandle,
9332 tagPresent: *mut ::std::os::raw::c_int,
9333 ) -> PhidgetReturnCode;
9334}
9335pub type PhidgetRFID_OnTagCallback = ::std::option::Option<
9336 unsafe extern "C" fn(
9337 ch: PhidgetRFIDHandle,
9338 ctx: *mut ::std::os::raw::c_void,
9339 tag: *const ::std::os::raw::c_char,
9340 protocol: PhidgetRFID_Protocol,
9341 ),
9342>;
9343extern "C" {
9344 pub fn PhidgetRFID_setOnTagHandler(
9345 ch: PhidgetRFIDHandle,
9346 fptr: PhidgetRFID_OnTagCallback,
9347 ctx: *mut ::std::os::raw::c_void,
9348 ) -> PhidgetReturnCode;
9349}
9350pub type PhidgetRFID_OnTagLostCallback = ::std::option::Option<
9351 unsafe extern "C" fn(
9352 ch: PhidgetRFIDHandle,
9353 ctx: *mut ::std::os::raw::c_void,
9354 tag: *const ::std::os::raw::c_char,
9355 protocol: PhidgetRFID_Protocol,
9356 ),
9357>;
9358extern "C" {
9359 pub fn PhidgetRFID_setOnTagLostHandler(
9360 ch: PhidgetRFIDHandle,
9361 fptr: PhidgetRFID_OnTagLostCallback,
9362 ctx: *mut ::std::os::raw::c_void,
9363 ) -> PhidgetReturnCode;
9364}
9365#[repr(C)]
9366#[derive(Debug, Copy, Clone)]
9367pub struct _PhidgetResistanceInput {
9368 _unused: [u8; 0],
9369}
9370pub type PhidgetResistanceInputHandle = *mut _PhidgetResistanceInput;
9371extern "C" {
9372 pub fn PhidgetResistanceInput_create(
9373 ch: *mut PhidgetResistanceInputHandle,
9374 ) -> PhidgetReturnCode;
9375}
9376extern "C" {
9377 pub fn PhidgetResistanceInput_delete(
9378 ch: *mut PhidgetResistanceInputHandle,
9379 ) -> PhidgetReturnCode;
9380}
9381extern "C" {
9382 pub fn PhidgetResistanceInput_setDataInterval(
9383 ch: PhidgetResistanceInputHandle,
9384 dataInterval: u32,
9385 ) -> PhidgetReturnCode;
9386}
9387extern "C" {
9388 pub fn PhidgetResistanceInput_getDataInterval(
9389 ch: PhidgetResistanceInputHandle,
9390 dataInterval: *mut u32,
9391 ) -> PhidgetReturnCode;
9392}
9393extern "C" {
9394 pub fn PhidgetResistanceInput_getMinDataInterval(
9395 ch: PhidgetResistanceInputHandle,
9396 minDataInterval: *mut u32,
9397 ) -> PhidgetReturnCode;
9398}
9399extern "C" {
9400 pub fn PhidgetResistanceInput_getMaxDataInterval(
9401 ch: PhidgetResistanceInputHandle,
9402 maxDataInterval: *mut u32,
9403 ) -> PhidgetReturnCode;
9404}
9405extern "C" {
9406 pub fn PhidgetResistanceInput_setDataRate(
9407 ch: PhidgetResistanceInputHandle,
9408 dataRate: f64,
9409 ) -> PhidgetReturnCode;
9410}
9411extern "C" {
9412 pub fn PhidgetResistanceInput_getDataRate(
9413 ch: PhidgetResistanceInputHandle,
9414 dataRate: *mut f64,
9415 ) -> PhidgetReturnCode;
9416}
9417extern "C" {
9418 pub fn PhidgetResistanceInput_getMinDataRate(
9419 ch: PhidgetResistanceInputHandle,
9420 minDataRate: *mut f64,
9421 ) -> PhidgetReturnCode;
9422}
9423extern "C" {
9424 pub fn PhidgetResistanceInput_getMaxDataRate(
9425 ch: PhidgetResistanceInputHandle,
9426 maxDataRate: *mut f64,
9427 ) -> PhidgetReturnCode;
9428}
9429extern "C" {
9430 pub fn PhidgetResistanceInput_getResistance(
9431 ch: PhidgetResistanceInputHandle,
9432 resistance: *mut f64,
9433 ) -> PhidgetReturnCode;
9434}
9435extern "C" {
9436 pub fn PhidgetResistanceInput_getMinResistance(
9437 ch: PhidgetResistanceInputHandle,
9438 minResistance: *mut f64,
9439 ) -> PhidgetReturnCode;
9440}
9441extern "C" {
9442 pub fn PhidgetResistanceInput_getMaxResistance(
9443 ch: PhidgetResistanceInputHandle,
9444 maxResistance: *mut f64,
9445 ) -> PhidgetReturnCode;
9446}
9447extern "C" {
9448 pub fn PhidgetResistanceInput_setResistanceChangeTrigger(
9449 ch: PhidgetResistanceInputHandle,
9450 resistanceChangeTrigger: f64,
9451 ) -> PhidgetReturnCode;
9452}
9453extern "C" {
9454 pub fn PhidgetResistanceInput_getResistanceChangeTrigger(
9455 ch: PhidgetResistanceInputHandle,
9456 resistanceChangeTrigger: *mut f64,
9457 ) -> PhidgetReturnCode;
9458}
9459extern "C" {
9460 pub fn PhidgetResistanceInput_getMinResistanceChangeTrigger(
9461 ch: PhidgetResistanceInputHandle,
9462 minResistanceChangeTrigger: *mut f64,
9463 ) -> PhidgetReturnCode;
9464}
9465extern "C" {
9466 pub fn PhidgetResistanceInput_getMaxResistanceChangeTrigger(
9467 ch: PhidgetResistanceInputHandle,
9468 maxResistanceChangeTrigger: *mut f64,
9469 ) -> PhidgetReturnCode;
9470}
9471extern "C" {
9472 pub fn PhidgetResistanceInput_setRTDWireSetup(
9473 ch: PhidgetResistanceInputHandle,
9474 RTDWireSetup: Phidget_RTDWireSetup,
9475 ) -> PhidgetReturnCode;
9476}
9477extern "C" {
9478 pub fn PhidgetResistanceInput_getRTDWireSetup(
9479 ch: PhidgetResistanceInputHandle,
9480 RTDWireSetup: *mut Phidget_RTDWireSetup,
9481 ) -> PhidgetReturnCode;
9482}
9483pub type PhidgetResistanceInput_OnResistanceChangeCallback = ::std::option::Option<
9484 unsafe extern "C" fn(
9485 ch: PhidgetResistanceInputHandle,
9486 ctx: *mut ::std::os::raw::c_void,
9487 resistance: f64,
9488 ),
9489>;
9490extern "C" {
9491 pub fn PhidgetResistanceInput_setOnResistanceChangeHandler(
9492 ch: PhidgetResistanceInputHandle,
9493 fptr: PhidgetResistanceInput_OnResistanceChangeCallback,
9494 ctx: *mut ::std::os::raw::c_void,
9495 ) -> PhidgetReturnCode;
9496}
9497#[repr(C)]
9498#[derive(Debug, Copy, Clone)]
9499pub struct _PhidgetSoundSensor {
9500 _unused: [u8; 0],
9501}
9502pub type PhidgetSoundSensorHandle = *mut _PhidgetSoundSensor;
9503extern "C" {
9504 pub fn PhidgetSoundSensor_create(ch: *mut PhidgetSoundSensorHandle) -> PhidgetReturnCode;
9505}
9506extern "C" {
9507 pub fn PhidgetSoundSensor_delete(ch: *mut PhidgetSoundSensorHandle) -> PhidgetReturnCode;
9508}
9509extern "C" {
9510 pub fn PhidgetSoundSensor_setDataInterval(
9511 ch: PhidgetSoundSensorHandle,
9512 dataInterval: u32,
9513 ) -> PhidgetReturnCode;
9514}
9515extern "C" {
9516 pub fn PhidgetSoundSensor_getDataInterval(
9517 ch: PhidgetSoundSensorHandle,
9518 dataInterval: *mut u32,
9519 ) -> PhidgetReturnCode;
9520}
9521extern "C" {
9522 pub fn PhidgetSoundSensor_getMinDataInterval(
9523 ch: PhidgetSoundSensorHandle,
9524 minDataInterval: *mut u32,
9525 ) -> PhidgetReturnCode;
9526}
9527extern "C" {
9528 pub fn PhidgetSoundSensor_getMaxDataInterval(
9529 ch: PhidgetSoundSensorHandle,
9530 maxDataInterval: *mut u32,
9531 ) -> PhidgetReturnCode;
9532}
9533extern "C" {
9534 pub fn PhidgetSoundSensor_setDataRate(
9535 ch: PhidgetSoundSensorHandle,
9536 dataRate: f64,
9537 ) -> PhidgetReturnCode;
9538}
9539extern "C" {
9540 pub fn PhidgetSoundSensor_getDataRate(
9541 ch: PhidgetSoundSensorHandle,
9542 dataRate: *mut f64,
9543 ) -> PhidgetReturnCode;
9544}
9545extern "C" {
9546 pub fn PhidgetSoundSensor_getMinDataRate(
9547 ch: PhidgetSoundSensorHandle,
9548 minDataRate: *mut f64,
9549 ) -> PhidgetReturnCode;
9550}
9551extern "C" {
9552 pub fn PhidgetSoundSensor_getMaxDataRate(
9553 ch: PhidgetSoundSensorHandle,
9554 maxDataRate: *mut f64,
9555 ) -> PhidgetReturnCode;
9556}
9557extern "C" {
9558 pub fn PhidgetSoundSensor_getdB(
9559 ch: PhidgetSoundSensorHandle,
9560 dB: *mut f64,
9561 ) -> PhidgetReturnCode;
9562}
9563extern "C" {
9564 pub fn PhidgetSoundSensor_getMaxdB(
9565 ch: PhidgetSoundSensorHandle,
9566 maxdB: *mut f64,
9567 ) -> PhidgetReturnCode;
9568}
9569extern "C" {
9570 pub fn PhidgetSoundSensor_getdBA(
9571 ch: PhidgetSoundSensorHandle,
9572 dBA: *mut f64,
9573 ) -> PhidgetReturnCode;
9574}
9575extern "C" {
9576 pub fn PhidgetSoundSensor_getdBC(
9577 ch: PhidgetSoundSensorHandle,
9578 dBC: *mut f64,
9579 ) -> PhidgetReturnCode;
9580}
9581extern "C" {
9582 pub fn PhidgetSoundSensor_getNoiseFloor(
9583 ch: PhidgetSoundSensorHandle,
9584 noiseFloor: *mut f64,
9585 ) -> PhidgetReturnCode;
9586}
9587extern "C" {
9588 pub fn PhidgetSoundSensor_getOctaves(
9589 ch: PhidgetSoundSensorHandle,
9590 octaves: *mut [f64; 10usize],
9591 ) -> PhidgetReturnCode;
9592}
9593extern "C" {
9594 pub fn PhidgetSoundSensor_setSPLChangeTrigger(
9595 ch: PhidgetSoundSensorHandle,
9596 SPLChangeTrigger: f64,
9597 ) -> PhidgetReturnCode;
9598}
9599extern "C" {
9600 pub fn PhidgetSoundSensor_getSPLChangeTrigger(
9601 ch: PhidgetSoundSensorHandle,
9602 SPLChangeTrigger: *mut f64,
9603 ) -> PhidgetReturnCode;
9604}
9605extern "C" {
9606 pub fn PhidgetSoundSensor_getMinSPLChangeTrigger(
9607 ch: PhidgetSoundSensorHandle,
9608 minSPLChangeTrigger: *mut f64,
9609 ) -> PhidgetReturnCode;
9610}
9611extern "C" {
9612 pub fn PhidgetSoundSensor_getMaxSPLChangeTrigger(
9613 ch: PhidgetSoundSensorHandle,
9614 maxSPLChangeTrigger: *mut f64,
9615 ) -> PhidgetReturnCode;
9616}
9617extern "C" {
9618 pub fn PhidgetSoundSensor_setSPLRange(
9619 ch: PhidgetSoundSensorHandle,
9620 SPLRange: PhidgetSoundSensor_SPLRange,
9621 ) -> PhidgetReturnCode;
9622}
9623extern "C" {
9624 pub fn PhidgetSoundSensor_getSPLRange(
9625 ch: PhidgetSoundSensorHandle,
9626 SPLRange: *mut PhidgetSoundSensor_SPLRange,
9627 ) -> PhidgetReturnCode;
9628}
9629pub type PhidgetSoundSensor_OnSPLChangeCallback = ::std::option::Option<
9630 unsafe extern "C" fn(
9631 ch: PhidgetSoundSensorHandle,
9632 ctx: *mut ::std::os::raw::c_void,
9633 dB: f64,
9634 dBA: f64,
9635 dBC: f64,
9636 octaves: *const f64,
9637 ),
9638>;
9639extern "C" {
9640 pub fn PhidgetSoundSensor_setOnSPLChangeHandler(
9641 ch: PhidgetSoundSensorHandle,
9642 fptr: PhidgetSoundSensor_OnSPLChangeCallback,
9643 ctx: *mut ::std::os::raw::c_void,
9644 ) -> PhidgetReturnCode;
9645}
9646#[repr(C)]
9647#[derive(Debug, Copy, Clone)]
9648pub struct _PhidgetSpatial {
9649 _unused: [u8; 0],
9650}
9651pub type PhidgetSpatialHandle = *mut _PhidgetSpatial;
9652extern "C" {
9653 pub fn PhidgetSpatial_create(ch: *mut PhidgetSpatialHandle) -> PhidgetReturnCode;
9654}
9655extern "C" {
9656 pub fn PhidgetSpatial_delete(ch: *mut PhidgetSpatialHandle) -> PhidgetReturnCode;
9657}
9658extern "C" {
9659 pub fn PhidgetSpatial_setAHRSParameters(
9660 ch: PhidgetSpatialHandle,
9661 angularVelocityThreshold: f64,
9662 angularVelocityDeltaThreshold: f64,
9663 accelerationThreshold: f64,
9664 magTime: f64,
9665 accelTime: f64,
9666 biasTime: f64,
9667 ) -> PhidgetReturnCode;
9668}
9669extern "C" {
9670 pub fn PhidgetSpatial_setMagnetometerCorrectionParameters(
9671 ch: PhidgetSpatialHandle,
9672 magneticField: f64,
9673 offset0: f64,
9674 offset1: f64,
9675 offset2: f64,
9676 gain0: f64,
9677 gain1: f64,
9678 gain2: f64,
9679 T0: f64,
9680 T1: f64,
9681 T2: f64,
9682 T3: f64,
9683 T4: f64,
9684 T5: f64,
9685 ) -> PhidgetReturnCode;
9686}
9687extern "C" {
9688 pub fn PhidgetSpatial_resetMagnetometerCorrectionParameters(
9689 ch: PhidgetSpatialHandle,
9690 ) -> PhidgetReturnCode;
9691}
9692extern "C" {
9693 pub fn PhidgetSpatial_saveMagnetometerCorrectionParameters(
9694 ch: PhidgetSpatialHandle,
9695 ) -> PhidgetReturnCode;
9696}
9697extern "C" {
9698 pub fn PhidgetSpatial_zeroAlgorithm(ch: PhidgetSpatialHandle) -> PhidgetReturnCode;
9699}
9700extern "C" {
9701 pub fn PhidgetSpatial_zeroGyro(ch: PhidgetSpatialHandle) -> PhidgetReturnCode;
9702}
9703extern "C" {
9704 pub fn PhidgetSpatial_getMinAcceleration(
9705 ch: PhidgetSpatialHandle,
9706 minAcceleration: *mut [f64; 3usize],
9707 ) -> PhidgetReturnCode;
9708}
9709extern "C" {
9710 pub fn PhidgetSpatial_getMaxAcceleration(
9711 ch: PhidgetSpatialHandle,
9712 maxAcceleration: *mut [f64; 3usize],
9713 ) -> PhidgetReturnCode;
9714}
9715extern "C" {
9716 pub fn PhidgetSpatial_setAlgorithm(
9717 ch: PhidgetSpatialHandle,
9718 algorithm: Phidget_SpatialAlgorithm,
9719 ) -> PhidgetReturnCode;
9720}
9721extern "C" {
9722 pub fn PhidgetSpatial_getAlgorithm(
9723 ch: PhidgetSpatialHandle,
9724 algorithm: *mut Phidget_SpatialAlgorithm,
9725 ) -> PhidgetReturnCode;
9726}
9727extern "C" {
9728 pub fn PhidgetSpatial_setAlgorithmMagnetometerGain(
9729 ch: PhidgetSpatialHandle,
9730 algorithmMagnetometerGain: f64,
9731 ) -> PhidgetReturnCode;
9732}
9733extern "C" {
9734 pub fn PhidgetSpatial_getAlgorithmMagnetometerGain(
9735 ch: PhidgetSpatialHandle,
9736 algorithmMagnetometerGain: *mut f64,
9737 ) -> PhidgetReturnCode;
9738}
9739extern "C" {
9740 pub fn PhidgetSpatial_getMinAngularRate(
9741 ch: PhidgetSpatialHandle,
9742 minAngularRate: *mut [f64; 3usize],
9743 ) -> PhidgetReturnCode;
9744}
9745extern "C" {
9746 pub fn PhidgetSpatial_getMaxAngularRate(
9747 ch: PhidgetSpatialHandle,
9748 maxAngularRate: *mut [f64; 3usize],
9749 ) -> PhidgetReturnCode;
9750}
9751extern "C" {
9752 pub fn PhidgetSpatial_setDataInterval(
9753 ch: PhidgetSpatialHandle,
9754 dataInterval: u32,
9755 ) -> PhidgetReturnCode;
9756}
9757extern "C" {
9758 pub fn PhidgetSpatial_getDataInterval(
9759 ch: PhidgetSpatialHandle,
9760 dataInterval: *mut u32,
9761 ) -> PhidgetReturnCode;
9762}
9763extern "C" {
9764 pub fn PhidgetSpatial_getMinDataInterval(
9765 ch: PhidgetSpatialHandle,
9766 minDataInterval: *mut u32,
9767 ) -> PhidgetReturnCode;
9768}
9769extern "C" {
9770 pub fn PhidgetSpatial_getMaxDataInterval(
9771 ch: PhidgetSpatialHandle,
9772 maxDataInterval: *mut u32,
9773 ) -> PhidgetReturnCode;
9774}
9775extern "C" {
9776 pub fn PhidgetSpatial_setDataRate(ch: PhidgetSpatialHandle, dataRate: f64)
9777 -> PhidgetReturnCode;
9778}
9779extern "C" {
9780 pub fn PhidgetSpatial_getDataRate(
9781 ch: PhidgetSpatialHandle,
9782 dataRate: *mut f64,
9783 ) -> PhidgetReturnCode;
9784}
9785extern "C" {
9786 pub fn PhidgetSpatial_getMinDataRate(
9787 ch: PhidgetSpatialHandle,
9788 minDataRate: *mut f64,
9789 ) -> PhidgetReturnCode;
9790}
9791extern "C" {
9792 pub fn PhidgetSpatial_getMaxDataRate(
9793 ch: PhidgetSpatialHandle,
9794 maxDataRate: *mut f64,
9795 ) -> PhidgetReturnCode;
9796}
9797extern "C" {
9798 pub fn PhidgetSpatial_getEulerAngles(
9799 ch: PhidgetSpatialHandle,
9800 eulerAngles: *mut PhidgetSpatial_SpatialEulerAngles,
9801 ) -> PhidgetReturnCode;
9802}
9803extern "C" {
9804 pub fn PhidgetSpatial_setHeatingEnabled(
9805 ch: PhidgetSpatialHandle,
9806 heatingEnabled: ::std::os::raw::c_int,
9807 ) -> PhidgetReturnCode;
9808}
9809extern "C" {
9810 pub fn PhidgetSpatial_getHeatingEnabled(
9811 ch: PhidgetSpatialHandle,
9812 heatingEnabled: *mut ::std::os::raw::c_int,
9813 ) -> PhidgetReturnCode;
9814}
9815extern "C" {
9816 pub fn PhidgetSpatial_getMinMagneticField(
9817 ch: PhidgetSpatialHandle,
9818 minMagneticField: *mut [f64; 3usize],
9819 ) -> PhidgetReturnCode;
9820}
9821extern "C" {
9822 pub fn PhidgetSpatial_getMaxMagneticField(
9823 ch: PhidgetSpatialHandle,
9824 maxMagneticField: *mut [f64; 3usize],
9825 ) -> PhidgetReturnCode;
9826}
9827extern "C" {
9828 pub fn PhidgetSpatial_setPrecision(
9829 ch: PhidgetSpatialHandle,
9830 precision: Phidget_SpatialPrecision,
9831 ) -> PhidgetReturnCode;
9832}
9833extern "C" {
9834 pub fn PhidgetSpatial_getPrecision(
9835 ch: PhidgetSpatialHandle,
9836 precision: *mut Phidget_SpatialPrecision,
9837 ) -> PhidgetReturnCode;
9838}
9839extern "C" {
9840 pub fn PhidgetSpatial_getQuaternion(
9841 ch: PhidgetSpatialHandle,
9842 quaternion: *mut PhidgetSpatial_SpatialQuaternion,
9843 ) -> PhidgetReturnCode;
9844}
9845pub type PhidgetSpatial_OnAlgorithmDataCallback = ::std::option::Option<
9846 unsafe extern "C" fn(
9847 ch: PhidgetSpatialHandle,
9848 ctx: *mut ::std::os::raw::c_void,
9849 quaternion: *const f64,
9850 timestamp: f64,
9851 ),
9852>;
9853extern "C" {
9854 pub fn PhidgetSpatial_setOnAlgorithmDataHandler(
9855 ch: PhidgetSpatialHandle,
9856 fptr: PhidgetSpatial_OnAlgorithmDataCallback,
9857 ctx: *mut ::std::os::raw::c_void,
9858 ) -> PhidgetReturnCode;
9859}
9860pub type PhidgetSpatial_OnSpatialDataCallback = ::std::option::Option<
9861 unsafe extern "C" fn(
9862 ch: PhidgetSpatialHandle,
9863 ctx: *mut ::std::os::raw::c_void,
9864 acceleration: *const f64,
9865 angularRate: *const f64,
9866 magneticField: *const f64,
9867 timestamp: f64,
9868 ),
9869>;
9870extern "C" {
9871 pub fn PhidgetSpatial_setOnSpatialDataHandler(
9872 ch: PhidgetSpatialHandle,
9873 fptr: PhidgetSpatial_OnSpatialDataCallback,
9874 ctx: *mut ::std::os::raw::c_void,
9875 ) -> PhidgetReturnCode;
9876}
9877#[repr(C)]
9878#[derive(Debug, Copy, Clone)]
9879pub struct _PhidgetStepper {
9880 _unused: [u8; 0],
9881}
9882pub type PhidgetStepperHandle = *mut _PhidgetStepper;
9883extern "C" {
9884 pub fn PhidgetStepper_create(ch: *mut PhidgetStepperHandle) -> PhidgetReturnCode;
9885}
9886extern "C" {
9887 pub fn PhidgetStepper_delete(ch: *mut PhidgetStepperHandle) -> PhidgetReturnCode;
9888}
9889extern "C" {
9890 pub fn PhidgetStepper_enableFailsafe(
9891 ch: PhidgetStepperHandle,
9892 failsafeTime: u32,
9893 ) -> PhidgetReturnCode;
9894}
9895extern "C" {
9896 pub fn PhidgetStepper_addPositionOffset(
9897 ch: PhidgetStepperHandle,
9898 positionOffset: f64,
9899 ) -> PhidgetReturnCode;
9900}
9901extern "C" {
9902 pub fn PhidgetStepper_resetFailsafe(ch: PhidgetStepperHandle) -> PhidgetReturnCode;
9903}
9904extern "C" {
9905 pub fn PhidgetStepper_setAcceleration(
9906 ch: PhidgetStepperHandle,
9907 acceleration: f64,
9908 ) -> PhidgetReturnCode;
9909}
9910extern "C" {
9911 pub fn PhidgetStepper_getAcceleration(
9912 ch: PhidgetStepperHandle,
9913 acceleration: *mut f64,
9914 ) -> PhidgetReturnCode;
9915}
9916extern "C" {
9917 pub fn PhidgetStepper_getMinAcceleration(
9918 ch: PhidgetStepperHandle,
9919 minAcceleration: *mut f64,
9920 ) -> PhidgetReturnCode;
9921}
9922extern "C" {
9923 pub fn PhidgetStepper_getMaxAcceleration(
9924 ch: PhidgetStepperHandle,
9925 maxAcceleration: *mut f64,
9926 ) -> PhidgetReturnCode;
9927}
9928extern "C" {
9929 pub fn PhidgetStepper_setControlMode(
9930 ch: PhidgetStepperHandle,
9931 controlMode: PhidgetStepper_ControlMode,
9932 ) -> PhidgetReturnCode;
9933}
9934extern "C" {
9935 pub fn PhidgetStepper_getControlMode(
9936 ch: PhidgetStepperHandle,
9937 controlMode: *mut PhidgetStepper_ControlMode,
9938 ) -> PhidgetReturnCode;
9939}
9940extern "C" {
9941 pub fn PhidgetStepper_setCurrentLimit(
9942 ch: PhidgetStepperHandle,
9943 currentLimit: f64,
9944 ) -> PhidgetReturnCode;
9945}
9946extern "C" {
9947 pub fn PhidgetStepper_getCurrentLimit(
9948 ch: PhidgetStepperHandle,
9949 currentLimit: *mut f64,
9950 ) -> PhidgetReturnCode;
9951}
9952extern "C" {
9953 pub fn PhidgetStepper_getMinCurrentLimit(
9954 ch: PhidgetStepperHandle,
9955 minCurrentLimit: *mut f64,
9956 ) -> PhidgetReturnCode;
9957}
9958extern "C" {
9959 pub fn PhidgetStepper_getMaxCurrentLimit(
9960 ch: PhidgetStepperHandle,
9961 maxCurrentLimit: *mut f64,
9962 ) -> PhidgetReturnCode;
9963}
9964extern "C" {
9965 pub fn PhidgetStepper_setDataInterval(
9966 ch: PhidgetStepperHandle,
9967 dataInterval: u32,
9968 ) -> PhidgetReturnCode;
9969}
9970extern "C" {
9971 pub fn PhidgetStepper_getDataInterval(
9972 ch: PhidgetStepperHandle,
9973 dataInterval: *mut u32,
9974 ) -> PhidgetReturnCode;
9975}
9976extern "C" {
9977 pub fn PhidgetStepper_getMinDataInterval(
9978 ch: PhidgetStepperHandle,
9979 minDataInterval: *mut u32,
9980 ) -> PhidgetReturnCode;
9981}
9982extern "C" {
9983 pub fn PhidgetStepper_getMaxDataInterval(
9984 ch: PhidgetStepperHandle,
9985 maxDataInterval: *mut u32,
9986 ) -> PhidgetReturnCode;
9987}
9988extern "C" {
9989 pub fn PhidgetStepper_setDataRate(ch: PhidgetStepperHandle, dataRate: f64)
9990 -> PhidgetReturnCode;
9991}
9992extern "C" {
9993 pub fn PhidgetStepper_getDataRate(
9994 ch: PhidgetStepperHandle,
9995 dataRate: *mut f64,
9996 ) -> PhidgetReturnCode;
9997}
9998extern "C" {
9999 pub fn PhidgetStepper_getMinDataRate(
10000 ch: PhidgetStepperHandle,
10001 minDataRate: *mut f64,
10002 ) -> PhidgetReturnCode;
10003}
10004extern "C" {
10005 pub fn PhidgetStepper_getMaxDataRate(
10006 ch: PhidgetStepperHandle,
10007 maxDataRate: *mut f64,
10008 ) -> PhidgetReturnCode;
10009}
10010extern "C" {
10011 pub fn PhidgetStepper_setEngaged(
10012 ch: PhidgetStepperHandle,
10013 engaged: ::std::os::raw::c_int,
10014 ) -> PhidgetReturnCode;
10015}
10016extern "C" {
10017 pub fn PhidgetStepper_getEngaged(
10018 ch: PhidgetStepperHandle,
10019 engaged: *mut ::std::os::raw::c_int,
10020 ) -> PhidgetReturnCode;
10021}
10022extern "C" {
10023 pub fn PhidgetStepper_getMinFailsafeTime(
10024 ch: PhidgetStepperHandle,
10025 minFailsafeTime: *mut u32,
10026 ) -> PhidgetReturnCode;
10027}
10028extern "C" {
10029 pub fn PhidgetStepper_getMaxFailsafeTime(
10030 ch: PhidgetStepperHandle,
10031 maxFailsafeTime: *mut u32,
10032 ) -> PhidgetReturnCode;
10033}
10034extern "C" {
10035 pub fn PhidgetStepper_setHoldingCurrentLimit(
10036 ch: PhidgetStepperHandle,
10037 holdingCurrentLimit: f64,
10038 ) -> PhidgetReturnCode;
10039}
10040extern "C" {
10041 pub fn PhidgetStepper_getHoldingCurrentLimit(
10042 ch: PhidgetStepperHandle,
10043 holdingCurrentLimit: *mut f64,
10044 ) -> PhidgetReturnCode;
10045}
10046extern "C" {
10047 pub fn PhidgetStepper_getIsMoving(
10048 ch: PhidgetStepperHandle,
10049 isMoving: *mut ::std::os::raw::c_int,
10050 ) -> PhidgetReturnCode;
10051}
10052extern "C" {
10053 pub fn PhidgetStepper_getPosition(
10054 ch: PhidgetStepperHandle,
10055 position: *mut f64,
10056 ) -> PhidgetReturnCode;
10057}
10058extern "C" {
10059 pub fn PhidgetStepper_getMinPosition(
10060 ch: PhidgetStepperHandle,
10061 minPosition: *mut f64,
10062 ) -> PhidgetReturnCode;
10063}
10064extern "C" {
10065 pub fn PhidgetStepper_getMaxPosition(
10066 ch: PhidgetStepperHandle,
10067 maxPosition: *mut f64,
10068 ) -> PhidgetReturnCode;
10069}
10070extern "C" {
10071 pub fn PhidgetStepper_setRescaleFactor(
10072 ch: PhidgetStepperHandle,
10073 rescaleFactor: f64,
10074 ) -> PhidgetReturnCode;
10075}
10076extern "C" {
10077 pub fn PhidgetStepper_getRescaleFactor(
10078 ch: PhidgetStepperHandle,
10079 rescaleFactor: *mut f64,
10080 ) -> PhidgetReturnCode;
10081}
10082extern "C" {
10083 pub fn PhidgetStepper_setTargetPosition(
10084 ch: PhidgetStepperHandle,
10085 targetPosition: f64,
10086 ) -> PhidgetReturnCode;
10087}
10088extern "C" {
10089 pub fn PhidgetStepper_setTargetPosition_async(
10090 ch: PhidgetStepperHandle,
10091 targetPosition: f64,
10092 fptr: Phidget_AsyncCallback,
10093 ctx: *mut ::std::os::raw::c_void,
10094 );
10095}
10096extern "C" {
10097 pub fn PhidgetStepper_getTargetPosition(
10098 ch: PhidgetStepperHandle,
10099 targetPosition: *mut f64,
10100 ) -> PhidgetReturnCode;
10101}
10102extern "C" {
10103 pub fn PhidgetStepper_getVelocity(
10104 ch: PhidgetStepperHandle,
10105 velocity: *mut f64,
10106 ) -> PhidgetReturnCode;
10107}
10108extern "C" {
10109 pub fn PhidgetStepper_setVelocityLimit(
10110 ch: PhidgetStepperHandle,
10111 velocityLimit: f64,
10112 ) -> PhidgetReturnCode;
10113}
10114extern "C" {
10115 pub fn PhidgetStepper_getVelocityLimit(
10116 ch: PhidgetStepperHandle,
10117 velocityLimit: *mut f64,
10118 ) -> PhidgetReturnCode;
10119}
10120extern "C" {
10121 pub fn PhidgetStepper_getMinVelocityLimit(
10122 ch: PhidgetStepperHandle,
10123 minVelocityLimit: *mut f64,
10124 ) -> PhidgetReturnCode;
10125}
10126extern "C" {
10127 pub fn PhidgetStepper_getMaxVelocityLimit(
10128 ch: PhidgetStepperHandle,
10129 maxVelocityLimit: *mut f64,
10130 ) -> PhidgetReturnCode;
10131}
10132pub type PhidgetStepper_OnPositionChangeCallback = ::std::option::Option<
10133 unsafe extern "C" fn(ch: PhidgetStepperHandle, ctx: *mut ::std::os::raw::c_void, position: f64),
10134>;
10135extern "C" {
10136 pub fn PhidgetStepper_setOnPositionChangeHandler(
10137 ch: PhidgetStepperHandle,
10138 fptr: PhidgetStepper_OnPositionChangeCallback,
10139 ctx: *mut ::std::os::raw::c_void,
10140 ) -> PhidgetReturnCode;
10141}
10142pub type PhidgetStepper_OnStoppedCallback = ::std::option::Option<
10143 unsafe extern "C" fn(ch: PhidgetStepperHandle, ctx: *mut ::std::os::raw::c_void),
10144>;
10145extern "C" {
10146 pub fn PhidgetStepper_setOnStoppedHandler(
10147 ch: PhidgetStepperHandle,
10148 fptr: PhidgetStepper_OnStoppedCallback,
10149 ctx: *mut ::std::os::raw::c_void,
10150 ) -> PhidgetReturnCode;
10151}
10152pub type PhidgetStepper_OnVelocityChangeCallback = ::std::option::Option<
10153 unsafe extern "C" fn(ch: PhidgetStepperHandle, ctx: *mut ::std::os::raw::c_void, velocity: f64),
10154>;
10155extern "C" {
10156 pub fn PhidgetStepper_setOnVelocityChangeHandler(
10157 ch: PhidgetStepperHandle,
10158 fptr: PhidgetStepper_OnVelocityChangeCallback,
10159 ctx: *mut ::std::os::raw::c_void,
10160 ) -> PhidgetReturnCode;
10161}
10162#[repr(C)]
10163#[derive(Debug, Copy, Clone)]
10164pub struct _PhidgetTemperatureSensor {
10165 _unused: [u8; 0],
10166}
10167pub type PhidgetTemperatureSensorHandle = *mut _PhidgetTemperatureSensor;
10168extern "C" {
10169 pub fn PhidgetTemperatureSensor_create(
10170 ch: *mut PhidgetTemperatureSensorHandle,
10171 ) -> PhidgetReturnCode;
10172}
10173extern "C" {
10174 pub fn PhidgetTemperatureSensor_delete(
10175 ch: *mut PhidgetTemperatureSensorHandle,
10176 ) -> PhidgetReturnCode;
10177}
10178extern "C" {
10179 pub fn PhidgetTemperatureSensor_setDataInterval(
10180 ch: PhidgetTemperatureSensorHandle,
10181 dataInterval: u32,
10182 ) -> PhidgetReturnCode;
10183}
10184extern "C" {
10185 pub fn PhidgetTemperatureSensor_getDataInterval(
10186 ch: PhidgetTemperatureSensorHandle,
10187 dataInterval: *mut u32,
10188 ) -> PhidgetReturnCode;
10189}
10190extern "C" {
10191 pub fn PhidgetTemperatureSensor_getMinDataInterval(
10192 ch: PhidgetTemperatureSensorHandle,
10193 minDataInterval: *mut u32,
10194 ) -> PhidgetReturnCode;
10195}
10196extern "C" {
10197 pub fn PhidgetTemperatureSensor_getMaxDataInterval(
10198 ch: PhidgetTemperatureSensorHandle,
10199 maxDataInterval: *mut u32,
10200 ) -> PhidgetReturnCode;
10201}
10202extern "C" {
10203 pub fn PhidgetTemperatureSensor_setDataRate(
10204 ch: PhidgetTemperatureSensorHandle,
10205 dataRate: f64,
10206 ) -> PhidgetReturnCode;
10207}
10208extern "C" {
10209 pub fn PhidgetTemperatureSensor_getDataRate(
10210 ch: PhidgetTemperatureSensorHandle,
10211 dataRate: *mut f64,
10212 ) -> PhidgetReturnCode;
10213}
10214extern "C" {
10215 pub fn PhidgetTemperatureSensor_getMinDataRate(
10216 ch: PhidgetTemperatureSensorHandle,
10217 minDataRate: *mut f64,
10218 ) -> PhidgetReturnCode;
10219}
10220extern "C" {
10221 pub fn PhidgetTemperatureSensor_getMaxDataRate(
10222 ch: PhidgetTemperatureSensorHandle,
10223 maxDataRate: *mut f64,
10224 ) -> PhidgetReturnCode;
10225}
10226extern "C" {
10227 pub fn PhidgetTemperatureSensor_setRTDType(
10228 ch: PhidgetTemperatureSensorHandle,
10229 RTDType: PhidgetTemperatureSensor_RTDType,
10230 ) -> PhidgetReturnCode;
10231}
10232extern "C" {
10233 pub fn PhidgetTemperatureSensor_getRTDType(
10234 ch: PhidgetTemperatureSensorHandle,
10235 RTDType: *mut PhidgetTemperatureSensor_RTDType,
10236 ) -> PhidgetReturnCode;
10237}
10238extern "C" {
10239 pub fn PhidgetTemperatureSensor_setRTDWireSetup(
10240 ch: PhidgetTemperatureSensorHandle,
10241 RTDWireSetup: Phidget_RTDWireSetup,
10242 ) -> PhidgetReturnCode;
10243}
10244extern "C" {
10245 pub fn PhidgetTemperatureSensor_getRTDWireSetup(
10246 ch: PhidgetTemperatureSensorHandle,
10247 RTDWireSetup: *mut Phidget_RTDWireSetup,
10248 ) -> PhidgetReturnCode;
10249}
10250extern "C" {
10251 pub fn PhidgetTemperatureSensor_getTemperature(
10252 ch: PhidgetTemperatureSensorHandle,
10253 temperature: *mut f64,
10254 ) -> PhidgetReturnCode;
10255}
10256extern "C" {
10257 pub fn PhidgetTemperatureSensor_getMinTemperature(
10258 ch: PhidgetTemperatureSensorHandle,
10259 minTemperature: *mut f64,
10260 ) -> PhidgetReturnCode;
10261}
10262extern "C" {
10263 pub fn PhidgetTemperatureSensor_getMaxTemperature(
10264 ch: PhidgetTemperatureSensorHandle,
10265 maxTemperature: *mut f64,
10266 ) -> PhidgetReturnCode;
10267}
10268extern "C" {
10269 pub fn PhidgetTemperatureSensor_setTemperatureChangeTrigger(
10270 ch: PhidgetTemperatureSensorHandle,
10271 temperatureChangeTrigger: f64,
10272 ) -> PhidgetReturnCode;
10273}
10274extern "C" {
10275 pub fn PhidgetTemperatureSensor_getTemperatureChangeTrigger(
10276 ch: PhidgetTemperatureSensorHandle,
10277 temperatureChangeTrigger: *mut f64,
10278 ) -> PhidgetReturnCode;
10279}
10280extern "C" {
10281 pub fn PhidgetTemperatureSensor_getMinTemperatureChangeTrigger(
10282 ch: PhidgetTemperatureSensorHandle,
10283 minTemperatureChangeTrigger: *mut f64,
10284 ) -> PhidgetReturnCode;
10285}
10286extern "C" {
10287 pub fn PhidgetTemperatureSensor_getMaxTemperatureChangeTrigger(
10288 ch: PhidgetTemperatureSensorHandle,
10289 maxTemperatureChangeTrigger: *mut f64,
10290 ) -> PhidgetReturnCode;
10291}
10292extern "C" {
10293 pub fn PhidgetTemperatureSensor_setThermocoupleType(
10294 ch: PhidgetTemperatureSensorHandle,
10295 thermocoupleType: PhidgetTemperatureSensor_ThermocoupleType,
10296 ) -> PhidgetReturnCode;
10297}
10298extern "C" {
10299 pub fn PhidgetTemperatureSensor_getThermocoupleType(
10300 ch: PhidgetTemperatureSensorHandle,
10301 thermocoupleType: *mut PhidgetTemperatureSensor_ThermocoupleType,
10302 ) -> PhidgetReturnCode;
10303}
10304pub type PhidgetTemperatureSensor_OnTemperatureChangeCallback = ::std::option::Option<
10305 unsafe extern "C" fn(
10306 ch: PhidgetTemperatureSensorHandle,
10307 ctx: *mut ::std::os::raw::c_void,
10308 temperature: f64,
10309 ),
10310>;
10311extern "C" {
10312 pub fn PhidgetTemperatureSensor_setOnTemperatureChangeHandler(
10313 ch: PhidgetTemperatureSensorHandle,
10314 fptr: PhidgetTemperatureSensor_OnTemperatureChangeCallback,
10315 ctx: *mut ::std::os::raw::c_void,
10316 ) -> PhidgetReturnCode;
10317}
10318#[repr(C)]
10319#[derive(Debug, Copy, Clone)]
10320pub struct _PhidgetVoltageInput {
10321 _unused: [u8; 0],
10322}
10323pub type PhidgetVoltageInputHandle = *mut _PhidgetVoltageInput;
10324extern "C" {
10325 pub fn PhidgetVoltageInput_create(ch: *mut PhidgetVoltageInputHandle) -> PhidgetReturnCode;
10326}
10327extern "C" {
10328 pub fn PhidgetVoltageInput_delete(ch: *mut PhidgetVoltageInputHandle) -> PhidgetReturnCode;
10329}
10330extern "C" {
10331 pub fn PhidgetVoltageInput_setDataInterval(
10332 ch: PhidgetVoltageInputHandle,
10333 dataInterval: u32,
10334 ) -> PhidgetReturnCode;
10335}
10336extern "C" {
10337 pub fn PhidgetVoltageInput_getDataInterval(
10338 ch: PhidgetVoltageInputHandle,
10339 dataInterval: *mut u32,
10340 ) -> PhidgetReturnCode;
10341}
10342extern "C" {
10343 pub fn PhidgetVoltageInput_getMinDataInterval(
10344 ch: PhidgetVoltageInputHandle,
10345 minDataInterval: *mut u32,
10346 ) -> PhidgetReturnCode;
10347}
10348extern "C" {
10349 pub fn PhidgetVoltageInput_getMaxDataInterval(
10350 ch: PhidgetVoltageInputHandle,
10351 maxDataInterval: *mut u32,
10352 ) -> PhidgetReturnCode;
10353}
10354extern "C" {
10355 pub fn PhidgetVoltageInput_setDataRate(
10356 ch: PhidgetVoltageInputHandle,
10357 dataRate: f64,
10358 ) -> PhidgetReturnCode;
10359}
10360extern "C" {
10361 pub fn PhidgetVoltageInput_getDataRate(
10362 ch: PhidgetVoltageInputHandle,
10363 dataRate: *mut f64,
10364 ) -> PhidgetReturnCode;
10365}
10366extern "C" {
10367 pub fn PhidgetVoltageInput_getMinDataRate(
10368 ch: PhidgetVoltageInputHandle,
10369 minDataRate: *mut f64,
10370 ) -> PhidgetReturnCode;
10371}
10372extern "C" {
10373 pub fn PhidgetVoltageInput_getMaxDataRate(
10374 ch: PhidgetVoltageInputHandle,
10375 maxDataRate: *mut f64,
10376 ) -> PhidgetReturnCode;
10377}
10378extern "C" {
10379 pub fn PhidgetVoltageInput_setPowerSupply(
10380 ch: PhidgetVoltageInputHandle,
10381 powerSupply: Phidget_PowerSupply,
10382 ) -> PhidgetReturnCode;
10383}
10384extern "C" {
10385 pub fn PhidgetVoltageInput_getPowerSupply(
10386 ch: PhidgetVoltageInputHandle,
10387 powerSupply: *mut Phidget_PowerSupply,
10388 ) -> PhidgetReturnCode;
10389}
10390extern "C" {
10391 pub fn PhidgetVoltageInput_setSensorType(
10392 ch: PhidgetVoltageInputHandle,
10393 sensorType: PhidgetVoltageInput_SensorType,
10394 ) -> PhidgetReturnCode;
10395}
10396extern "C" {
10397 pub fn PhidgetVoltageInput_getSensorType(
10398 ch: PhidgetVoltageInputHandle,
10399 sensorType: *mut PhidgetVoltageInput_SensorType,
10400 ) -> PhidgetReturnCode;
10401}
10402extern "C" {
10403 pub fn PhidgetVoltageInput_getSensorUnit(
10404 ch: PhidgetVoltageInputHandle,
10405 sensorUnit: *mut Phidget_UnitInfo,
10406 ) -> PhidgetReturnCode;
10407}
10408extern "C" {
10409 pub fn PhidgetVoltageInput_getSensorValue(
10410 ch: PhidgetVoltageInputHandle,
10411 sensorValue: *mut f64,
10412 ) -> PhidgetReturnCode;
10413}
10414extern "C" {
10415 pub fn PhidgetVoltageInput_setSensorValueChangeTrigger(
10416 ch: PhidgetVoltageInputHandle,
10417 sensorValueChangeTrigger: f64,
10418 ) -> PhidgetReturnCode;
10419}
10420extern "C" {
10421 pub fn PhidgetVoltageInput_getSensorValueChangeTrigger(
10422 ch: PhidgetVoltageInputHandle,
10423 sensorValueChangeTrigger: *mut f64,
10424 ) -> PhidgetReturnCode;
10425}
10426extern "C" {
10427 pub fn PhidgetVoltageInput_getVoltage(
10428 ch: PhidgetVoltageInputHandle,
10429 voltage: *mut f64,
10430 ) -> PhidgetReturnCode;
10431}
10432extern "C" {
10433 pub fn PhidgetVoltageInput_getMinVoltage(
10434 ch: PhidgetVoltageInputHandle,
10435 minVoltage: *mut f64,
10436 ) -> PhidgetReturnCode;
10437}
10438extern "C" {
10439 pub fn PhidgetVoltageInput_getMaxVoltage(
10440 ch: PhidgetVoltageInputHandle,
10441 maxVoltage: *mut f64,
10442 ) -> PhidgetReturnCode;
10443}
10444extern "C" {
10445 pub fn PhidgetVoltageInput_setVoltageChangeTrigger(
10446 ch: PhidgetVoltageInputHandle,
10447 voltageChangeTrigger: f64,
10448 ) -> PhidgetReturnCode;
10449}
10450extern "C" {
10451 pub fn PhidgetVoltageInput_getVoltageChangeTrigger(
10452 ch: PhidgetVoltageInputHandle,
10453 voltageChangeTrigger: *mut f64,
10454 ) -> PhidgetReturnCode;
10455}
10456extern "C" {
10457 pub fn PhidgetVoltageInput_getMinVoltageChangeTrigger(
10458 ch: PhidgetVoltageInputHandle,
10459 minVoltageChangeTrigger: *mut f64,
10460 ) -> PhidgetReturnCode;
10461}
10462extern "C" {
10463 pub fn PhidgetVoltageInput_getMaxVoltageChangeTrigger(
10464 ch: PhidgetVoltageInputHandle,
10465 maxVoltageChangeTrigger: *mut f64,
10466 ) -> PhidgetReturnCode;
10467}
10468extern "C" {
10469 pub fn PhidgetVoltageInput_setVoltageRange(
10470 ch: PhidgetVoltageInputHandle,
10471 voltageRange: PhidgetVoltageInput_VoltageRange,
10472 ) -> PhidgetReturnCode;
10473}
10474extern "C" {
10475 pub fn PhidgetVoltageInput_getVoltageRange(
10476 ch: PhidgetVoltageInputHandle,
10477 voltageRange: *mut PhidgetVoltageInput_VoltageRange,
10478 ) -> PhidgetReturnCode;
10479}
10480pub type PhidgetVoltageInput_OnSensorChangeCallback = ::std::option::Option<
10481 unsafe extern "C" fn(
10482 ch: PhidgetVoltageInputHandle,
10483 ctx: *mut ::std::os::raw::c_void,
10484 sensorValue: f64,
10485 sensorUnit: *mut Phidget_UnitInfo,
10486 ),
10487>;
10488extern "C" {
10489 pub fn PhidgetVoltageInput_setOnSensorChangeHandler(
10490 ch: PhidgetVoltageInputHandle,
10491 fptr: PhidgetVoltageInput_OnSensorChangeCallback,
10492 ctx: *mut ::std::os::raw::c_void,
10493 ) -> PhidgetReturnCode;
10494}
10495pub type PhidgetVoltageInput_OnVoltageChangeCallback = ::std::option::Option<
10496 unsafe extern "C" fn(
10497 ch: PhidgetVoltageInputHandle,
10498 ctx: *mut ::std::os::raw::c_void,
10499 voltage: f64,
10500 ),
10501>;
10502extern "C" {
10503 pub fn PhidgetVoltageInput_setOnVoltageChangeHandler(
10504 ch: PhidgetVoltageInputHandle,
10505 fptr: PhidgetVoltageInput_OnVoltageChangeCallback,
10506 ctx: *mut ::std::os::raw::c_void,
10507 ) -> PhidgetReturnCode;
10508}
10509#[repr(C)]
10510#[derive(Debug, Copy, Clone)]
10511pub struct _PhidgetVoltageOutput {
10512 _unused: [u8; 0],
10513}
10514pub type PhidgetVoltageOutputHandle = *mut _PhidgetVoltageOutput;
10515extern "C" {
10516 pub fn PhidgetVoltageOutput_create(ch: *mut PhidgetVoltageOutputHandle) -> PhidgetReturnCode;
10517}
10518extern "C" {
10519 pub fn PhidgetVoltageOutput_delete(ch: *mut PhidgetVoltageOutputHandle) -> PhidgetReturnCode;
10520}
10521extern "C" {
10522 pub fn PhidgetVoltageOutput_enableFailsafe(
10523 ch: PhidgetVoltageOutputHandle,
10524 failsafeTime: u32,
10525 ) -> PhidgetReturnCode;
10526}
10527extern "C" {
10528 pub fn PhidgetVoltageOutput_resetFailsafe(ch: PhidgetVoltageOutputHandle) -> PhidgetReturnCode;
10529}
10530extern "C" {
10531 pub fn PhidgetVoltageOutput_setEnabled(
10532 ch: PhidgetVoltageOutputHandle,
10533 enabled: ::std::os::raw::c_int,
10534 ) -> PhidgetReturnCode;
10535}
10536extern "C" {
10537 pub fn PhidgetVoltageOutput_getEnabled(
10538 ch: PhidgetVoltageOutputHandle,
10539 enabled: *mut ::std::os::raw::c_int,
10540 ) -> PhidgetReturnCode;
10541}
10542extern "C" {
10543 pub fn PhidgetVoltageOutput_getMinFailsafeTime(
10544 ch: PhidgetVoltageOutputHandle,
10545 minFailsafeTime: *mut u32,
10546 ) -> PhidgetReturnCode;
10547}
10548extern "C" {
10549 pub fn PhidgetVoltageOutput_getMaxFailsafeTime(
10550 ch: PhidgetVoltageOutputHandle,
10551 maxFailsafeTime: *mut u32,
10552 ) -> PhidgetReturnCode;
10553}
10554extern "C" {
10555 pub fn PhidgetVoltageOutput_setVoltage(
10556 ch: PhidgetVoltageOutputHandle,
10557 voltage: f64,
10558 ) -> PhidgetReturnCode;
10559}
10560extern "C" {
10561 pub fn PhidgetVoltageOutput_setVoltage_async(
10562 ch: PhidgetVoltageOutputHandle,
10563 voltage: f64,
10564 fptr: Phidget_AsyncCallback,
10565 ctx: *mut ::std::os::raw::c_void,
10566 );
10567}
10568extern "C" {
10569 pub fn PhidgetVoltageOutput_getVoltage(
10570 ch: PhidgetVoltageOutputHandle,
10571 voltage: *mut f64,
10572 ) -> PhidgetReturnCode;
10573}
10574extern "C" {
10575 pub fn PhidgetVoltageOutput_getMinVoltage(
10576 ch: PhidgetVoltageOutputHandle,
10577 minVoltage: *mut f64,
10578 ) -> PhidgetReturnCode;
10579}
10580extern "C" {
10581 pub fn PhidgetVoltageOutput_getMaxVoltage(
10582 ch: PhidgetVoltageOutputHandle,
10583 maxVoltage: *mut f64,
10584 ) -> PhidgetReturnCode;
10585}
10586extern "C" {
10587 pub fn PhidgetVoltageOutput_setVoltageOutputRange(
10588 ch: PhidgetVoltageOutputHandle,
10589 voltageOutputRange: PhidgetVoltageOutput_VoltageOutputRange,
10590 ) -> PhidgetReturnCode;
10591}
10592extern "C" {
10593 pub fn PhidgetVoltageOutput_getVoltageOutputRange(
10594 ch: PhidgetVoltageOutputHandle,
10595 voltageOutputRange: *mut PhidgetVoltageOutput_VoltageOutputRange,
10596 ) -> PhidgetReturnCode;
10597}
10598#[repr(C)]
10599#[derive(Debug, Copy, Clone)]
10600pub struct _PhidgetVoltageRatioInput {
10601 _unused: [u8; 0],
10602}
10603pub type PhidgetVoltageRatioInputHandle = *mut _PhidgetVoltageRatioInput;
10604extern "C" {
10605 pub fn PhidgetVoltageRatioInput_create(
10606 ch: *mut PhidgetVoltageRatioInputHandle,
10607 ) -> PhidgetReturnCode;
10608}
10609extern "C" {
10610 pub fn PhidgetVoltageRatioInput_delete(
10611 ch: *mut PhidgetVoltageRatioInputHandle,
10612 ) -> PhidgetReturnCode;
10613}
10614extern "C" {
10615 pub fn PhidgetVoltageRatioInput_setBridgeEnabled(
10616 ch: PhidgetVoltageRatioInputHandle,
10617 bridgeEnabled: ::std::os::raw::c_int,
10618 ) -> PhidgetReturnCode;
10619}
10620extern "C" {
10621 pub fn PhidgetVoltageRatioInput_getBridgeEnabled(
10622 ch: PhidgetVoltageRatioInputHandle,
10623 bridgeEnabled: *mut ::std::os::raw::c_int,
10624 ) -> PhidgetReturnCode;
10625}
10626extern "C" {
10627 pub fn PhidgetVoltageRatioInput_setBridgeGain(
10628 ch: PhidgetVoltageRatioInputHandle,
10629 bridgeGain: PhidgetVoltageRatioInput_BridgeGain,
10630 ) -> PhidgetReturnCode;
10631}
10632extern "C" {
10633 pub fn PhidgetVoltageRatioInput_getBridgeGain(
10634 ch: PhidgetVoltageRatioInputHandle,
10635 bridgeGain: *mut PhidgetVoltageRatioInput_BridgeGain,
10636 ) -> PhidgetReturnCode;
10637}
10638extern "C" {
10639 pub fn PhidgetVoltageRatioInput_setDataInterval(
10640 ch: PhidgetVoltageRatioInputHandle,
10641 dataInterval: u32,
10642 ) -> PhidgetReturnCode;
10643}
10644extern "C" {
10645 pub fn PhidgetVoltageRatioInput_getDataInterval(
10646 ch: PhidgetVoltageRatioInputHandle,
10647 dataInterval: *mut u32,
10648 ) -> PhidgetReturnCode;
10649}
10650extern "C" {
10651 pub fn PhidgetVoltageRatioInput_getMinDataInterval(
10652 ch: PhidgetVoltageRatioInputHandle,
10653 minDataInterval: *mut u32,
10654 ) -> PhidgetReturnCode;
10655}
10656extern "C" {
10657 pub fn PhidgetVoltageRatioInput_getMaxDataInterval(
10658 ch: PhidgetVoltageRatioInputHandle,
10659 maxDataInterval: *mut u32,
10660 ) -> PhidgetReturnCode;
10661}
10662extern "C" {
10663 pub fn PhidgetVoltageRatioInput_setDataRate(
10664 ch: PhidgetVoltageRatioInputHandle,
10665 dataRate: f64,
10666 ) -> PhidgetReturnCode;
10667}
10668extern "C" {
10669 pub fn PhidgetVoltageRatioInput_getDataRate(
10670 ch: PhidgetVoltageRatioInputHandle,
10671 dataRate: *mut f64,
10672 ) -> PhidgetReturnCode;
10673}
10674extern "C" {
10675 pub fn PhidgetVoltageRatioInput_getMinDataRate(
10676 ch: PhidgetVoltageRatioInputHandle,
10677 minDataRate: *mut f64,
10678 ) -> PhidgetReturnCode;
10679}
10680extern "C" {
10681 pub fn PhidgetVoltageRatioInput_getMaxDataRate(
10682 ch: PhidgetVoltageRatioInputHandle,
10683 maxDataRate: *mut f64,
10684 ) -> PhidgetReturnCode;
10685}
10686extern "C" {
10687 pub fn PhidgetVoltageRatioInput_setSensorType(
10688 ch: PhidgetVoltageRatioInputHandle,
10689 sensorType: PhidgetVoltageRatioInput_SensorType,
10690 ) -> PhidgetReturnCode;
10691}
10692extern "C" {
10693 pub fn PhidgetVoltageRatioInput_getSensorType(
10694 ch: PhidgetVoltageRatioInputHandle,
10695 sensorType: *mut PhidgetVoltageRatioInput_SensorType,
10696 ) -> PhidgetReturnCode;
10697}
10698extern "C" {
10699 pub fn PhidgetVoltageRatioInput_getSensorUnit(
10700 ch: PhidgetVoltageRatioInputHandle,
10701 sensorUnit: *mut Phidget_UnitInfo,
10702 ) -> PhidgetReturnCode;
10703}
10704extern "C" {
10705 pub fn PhidgetVoltageRatioInput_getSensorValue(
10706 ch: PhidgetVoltageRatioInputHandle,
10707 sensorValue: *mut f64,
10708 ) -> PhidgetReturnCode;
10709}
10710extern "C" {
10711 pub fn PhidgetVoltageRatioInput_setSensorValueChangeTrigger(
10712 ch: PhidgetVoltageRatioInputHandle,
10713 sensorValueChangeTrigger: f64,
10714 ) -> PhidgetReturnCode;
10715}
10716extern "C" {
10717 pub fn PhidgetVoltageRatioInput_getSensorValueChangeTrigger(
10718 ch: PhidgetVoltageRatioInputHandle,
10719 sensorValueChangeTrigger: *mut f64,
10720 ) -> PhidgetReturnCode;
10721}
10722extern "C" {
10723 pub fn PhidgetVoltageRatioInput_getVoltageRatio(
10724 ch: PhidgetVoltageRatioInputHandle,
10725 voltageRatio: *mut f64,
10726 ) -> PhidgetReturnCode;
10727}
10728extern "C" {
10729 pub fn PhidgetVoltageRatioInput_getMinVoltageRatio(
10730 ch: PhidgetVoltageRatioInputHandle,
10731 minVoltageRatio: *mut f64,
10732 ) -> PhidgetReturnCode;
10733}
10734extern "C" {
10735 pub fn PhidgetVoltageRatioInput_getMaxVoltageRatio(
10736 ch: PhidgetVoltageRatioInputHandle,
10737 maxVoltageRatio: *mut f64,
10738 ) -> PhidgetReturnCode;
10739}
10740extern "C" {
10741 pub fn PhidgetVoltageRatioInput_setVoltageRatioChangeTrigger(
10742 ch: PhidgetVoltageRatioInputHandle,
10743 voltageRatioChangeTrigger: f64,
10744 ) -> PhidgetReturnCode;
10745}
10746extern "C" {
10747 pub fn PhidgetVoltageRatioInput_getVoltageRatioChangeTrigger(
10748 ch: PhidgetVoltageRatioInputHandle,
10749 voltageRatioChangeTrigger: *mut f64,
10750 ) -> PhidgetReturnCode;
10751}
10752extern "C" {
10753 pub fn PhidgetVoltageRatioInput_getMinVoltageRatioChangeTrigger(
10754 ch: PhidgetVoltageRatioInputHandle,
10755 minVoltageRatioChangeTrigger: *mut f64,
10756 ) -> PhidgetReturnCode;
10757}
10758extern "C" {
10759 pub fn PhidgetVoltageRatioInput_getMaxVoltageRatioChangeTrigger(
10760 ch: PhidgetVoltageRatioInputHandle,
10761 maxVoltageRatioChangeTrigger: *mut f64,
10762 ) -> PhidgetReturnCode;
10763}
10764pub type PhidgetVoltageRatioInput_OnSensorChangeCallback = ::std::option::Option<
10765 unsafe extern "C" fn(
10766 ch: PhidgetVoltageRatioInputHandle,
10767 ctx: *mut ::std::os::raw::c_void,
10768 sensorValue: f64,
10769 sensorUnit: *mut Phidget_UnitInfo,
10770 ),
10771>;
10772extern "C" {
10773 pub fn PhidgetVoltageRatioInput_setOnSensorChangeHandler(
10774 ch: PhidgetVoltageRatioInputHandle,
10775 fptr: PhidgetVoltageRatioInput_OnSensorChangeCallback,
10776 ctx: *mut ::std::os::raw::c_void,
10777 ) -> PhidgetReturnCode;
10778}
10779pub type PhidgetVoltageRatioInput_OnVoltageRatioChangeCallback = ::std::option::Option<
10780 unsafe extern "C" fn(
10781 ch: PhidgetVoltageRatioInputHandle,
10782 ctx: *mut ::std::os::raw::c_void,
10783 voltageRatio: f64,
10784 ),
10785>;
10786extern "C" {
10787 pub fn PhidgetVoltageRatioInput_setOnVoltageRatioChangeHandler(
10788 ch: PhidgetVoltageRatioInputHandle,
10789 fptr: PhidgetVoltageRatioInput_OnVoltageRatioChangeCallback,
10790 ctx: *mut ::std::os::raw::c_void,
10791 ) -> PhidgetReturnCode;
10792}
10793pub type __builtin_va_list = [__va_list_tag; 1usize];
10794#[repr(C)]
10795#[derive(Debug, Copy, Clone)]
10796pub struct __va_list_tag {
10797 pub gp_offset: ::std::os::raw::c_uint,
10798 pub fp_offset: ::std::os::raw::c_uint,
10799 pub overflow_arg_area: *mut ::std::os::raw::c_void,
10800 pub reg_save_area: *mut ::std::os::raw::c_void,
10801}
10802#[test]
10803fn bindgen_test_layout___va_list_tag() {
10804 const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
10805 let ptr = UNINIT.as_ptr();
10806 assert_eq!(
10807 ::std::mem::size_of::<__va_list_tag>(),
10808 24usize,
10809 "Size of __va_list_tag"
10810 );
10811 assert_eq!(
10812 ::std::mem::align_of::<__va_list_tag>(),
10813 8usize,
10814 "Alignment of __va_list_tag"
10815 );
10816 assert_eq!(
10817 unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
10818 0usize,
10819 "Offset of field: __va_list_tag::gp_offset"
10820 );
10821 assert_eq!(
10822 unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
10823 4usize,
10824 "Offset of field: __va_list_tag::fp_offset"
10825 );
10826 assert_eq!(
10827 unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
10828 8usize,
10829 "Offset of field: __va_list_tag::overflow_arg_area"
10830 );
10831 assert_eq!(
10832 unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
10833 16usize,
10834 "Offset of field: __va_list_tag::reg_save_area"
10835 );
10836}