#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
extern "C" {
pub fn rc_adc_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_adc_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_adc_read_raw(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_adc_read_volt(ch: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rc_adc_batt() -> f64;
}
extern "C" {
pub fn rc_adc_dc_jack() -> f64;
}
pub const BMP_OVERSAMPLE_1: rc_bmp_oversample_t = 4;
pub const BMP_OVERSAMPLE_2: rc_bmp_oversample_t = 8;
pub const BMP_OVERSAMPLE_4: rc_bmp_oversample_t = 12;
pub const BMP_OVERSAMPLE_8: rc_bmp_oversample_t = 16;
pub const BMP_OVERSAMPLE_16: rc_bmp_oversample_t = 20;
pub type rc_bmp_oversample_t = ::std::os::raw::c_uint;
pub const BMP_FILTER_OFF: rc_bmp_filter_t = 0;
pub const BMP_FILTER_2: rc_bmp_filter_t = 4;
pub const BMP_FILTER_4: rc_bmp_filter_t = 8;
pub const BMP_FILTER_8: rc_bmp_filter_t = 12;
pub const BMP_FILTER_16: rc_bmp_filter_t = 16;
pub type rc_bmp_filter_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct rc_bmp_data_t {
pub temp_c: f64,
pub alt_m: f64,
pub pressure_pa: f64,
}
#[test]
fn bindgen_test_layout_rc_bmp_data_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_bmp_data_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_bmp_data_t>(),
24usize,
concat!("Size of: ", stringify!(rc_bmp_data_t))
);
assert_eq!(
::std::mem::align_of::<rc_bmp_data_t>(),
8usize,
concat!("Alignment of ", stringify!(rc_bmp_data_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).temp_c) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_bmp_data_t), "::", stringify!(temp_c))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt_m) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(rc_bmp_data_t), "::", stringify!(alt_m))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pressure_pa) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rc_bmp_data_t),
"::",
stringify!(pressure_pa)
)
);
}
extern "C" {
pub fn rc_bmp_init(oversample: rc_bmp_oversample_t, filter: rc_bmp_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_bmp_set_sea_level_pressure_pa(pa: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_bmp_power_off() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_bmp_read(data: *mut rc_bmp_data_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_button_init(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
polarity: ::std::os::raw::c_char,
debounce_us: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_button_cleanup();
}
extern "C" {
pub fn rc_button_set_callbacks(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
press_func: ::std::option::Option<unsafe extern "C" fn()>,
release_func: ::std::option::Option<unsafe extern "C" fn()>,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_button_get_state(chip: ::std::os::raw::c_int, pin: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_button_wait_for_event(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
press_or_release: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub const RC_GOV_POWERSAVE: rc_governor_t = 0;
pub const RC_GOV_PERFORMANCE: rc_governor_t = 1;
pub const RC_GOV_ONDEMAND: rc_governor_t = 2;
pub const RC_GOV_SCHEDUTIL: rc_governor_t = 3;
pub const RC_GOV_CONSERVATIVE: rc_governor_t = 4;
pub type rc_governor_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_cpu_set_governor(gov: rc_governor_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_cpu_get_freq() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_cpu_print_freq() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_initialize() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_cleanup() -> ::std::os::raw::c_int;
}
pub const RELEASED: rc_button_state_t = 0;
pub const PRESSED: rc_button_state_t = 1;
pub type rc_button_state_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_set_pause_pressed_func(func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_pause_released_func(func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_mode_pressed_func(func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_mode_released_func(func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_get_pause_button() -> rc_button_state_t;
}
extern "C" {
pub fn rc_get_mode_button() -> rc_button_state_t;
}
extern "C" {
pub fn rc_get_encoder_pos(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_encoder_pos(ch: ::std::os::raw::c_int, value: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_enable_motors() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_disable_motors() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_motor(motor: ::std::os::raw::c_int, duty: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_motor_all(duty: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_motor_free_spin(motor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_motor_free_spin_all() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_motor_brake(motor: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_set_motor_brake_all() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_ch_raw(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_ch_normalized(ch: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rc_dsm_is_new_data() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_set_callback(func: ::std::option::Option<unsafe extern "C" fn()>);
}
extern "C" {
pub fn rc_dsm_set_disconnect_callback(func: ::std::option::Option<unsafe extern "C" fn()>);
}
extern "C" {
pub fn rc_dsm_is_connection_active() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_nanos_since_last_packet() -> i64;
}
extern "C" {
pub fn rc_dsm_resolution() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_channels() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_bind_routine() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_dsm_calibrate_routine() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_eqep_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_eqep_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_eqep_read(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_eqep_write(ch: ::std::os::raw::c_int, pos: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_pru_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_pru_cleanup();
}
extern "C" {
pub fn rc_encoder_pru_read() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_pru_write(pos: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_read(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_encoder_write(ch: ::std::os::raw::c_int, pos: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_gpio_init(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
handle_flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_gpio_set_value(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_gpio_get_value(chip: ::std::os::raw::c_int, pin: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_gpio_init_event(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
handle_flags: ::std::os::raw::c_int,
event_flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_gpio_poll(
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
timeout_ms: ::std::os::raw::c_int,
event_time_ns: *mut u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_gpio_cleanup(chip: ::std::os::raw::c_int, pin: ::std::os::raw::c_int);
}
extern "C" {
pub fn rc_i2c_init(bus: ::std::os::raw::c_int, devAddr: u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_close(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_set_device_address(bus: ::std::os::raw::c_int, devAddr: u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_read_byte(bus: ::std::os::raw::c_int, regAddr: u8, data: *mut u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_read_bytes(
bus: ::std::os::raw::c_int,
regAddr: u8,
count: usize,
data: *mut u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_read_word(bus: ::std::os::raw::c_int, regAddr: u8, data: *mut u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_read_words(
bus: ::std::os::raw::c_int,
regAddr: u8,
count: usize,
data: *mut u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_write_byte(bus: ::std::os::raw::c_int, regAddr: u8, data: u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_write_bytes(
bus: ::std::os::raw::c_int,
regAddr: u8,
count: usize,
data: *mut u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_write_word(bus: ::std::os::raw::c_int, regAddr: u8, data: u16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_write_words(
bus: ::std::os::raw::c_int,
regAddr: u8,
count: usize,
data: *mut u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_send_bytes(bus: ::std::os::raw::c_int, count: usize, data: *mut u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_send_byte(bus: ::std::os::raw::c_int, data: u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_lock_bus(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_unlock_bus(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_get_lock(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_i2c_get_fd(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub const RC_LED_GREEN: rc_led_t = 0;
pub const RC_LED_RED: rc_led_t = 1;
pub const RC_LED_USR0: rc_led_t = 2;
pub const RC_LED_USR1: rc_led_t = 3;
pub const RC_LED_USR2: rc_led_t = 4;
pub const RC_LED_USR3: rc_led_t = 5;
pub const RC_LED_BAT25: rc_led_t = 6;
pub const RC_LED_BAT50: rc_led_t = 7;
pub const RC_LED_BAT75: rc_led_t = 8;
pub const RC_LED_BAT100: rc_led_t = 9;
pub const RC_LED_WIFI: rc_led_t = 10;
pub type rc_led_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_led_set(led: rc_led_t, value: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_led_cleanup();
}
extern "C" {
pub fn rc_led_get(led: rc_led_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_led_blink(led: rc_led_t, hz: f32, duration: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_led_stop_blink(led: rc_led_t);
}
extern "C" {
pub fn rc_led_stop_blink_all();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rc_vector_t {
pub len: ::std::os::raw::c_int,
pub d: *mut f64,
pub initialized: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_rc_vector_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_vector_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_vector_t>(),
12usize,
concat!("Size of: ", stringify!(rc_vector_t))
);
assert_eq!(
::std::mem::align_of::<rc_vector_t>(),
4usize,
concat!("Alignment of ", stringify!(rc_vector_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_vector_t), "::", stringify!(len))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
4usize,
concat!("Offset of field: ", stringify!(rc_vector_t), "::", stringify!(d))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rc_vector_t),
"::",
stringify!(initialized)
)
);
}
impl Default for rc_vector_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn rc_vector_empty() -> rc_vector_t;
}
extern "C" {
pub fn rc_vector_alloc(v: *mut rc_vector_t, length: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_free(v: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_zeros(v: *mut rc_vector_t, length: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_ones(v: *mut rc_vector_t, length: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_random(v: *mut rc_vector_t, length: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_fibonnaci(v: *mut rc_vector_t, length: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_from_array(
v: *mut rc_vector_t,
ptr: *mut f64,
length: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_duplicate(a: rc_vector_t, b: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_print(v: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_print_sci(v: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_zero_out(v: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_times_scalar(v: *mut rc_vector_t, s: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_norm(v: rc_vector_t, p: f64) -> f64;
}
extern "C" {
pub fn rc_vector_max(v: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_min(v: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_std_dev(v: rc_vector_t) -> f64;
}
extern "C" {
pub fn rc_vector_mean(v: rc_vector_t) -> f64;
}
extern "C" {
pub fn rc_vector_projection(v: rc_vector_t, e: rc_vector_t, p: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_dot_product(v1: rc_vector_t, v2: rc_vector_t) -> f64;
}
extern "C" {
pub fn rc_vector_cross_product(v1: rc_vector_t, v2: rc_vector_t, p: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_sum(v1: rc_vector_t, v2: rc_vector_t, s: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_sum_inplace(v1: *mut rc_vector_t, v2: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_vector_subtract(v1: rc_vector_t, v2: rc_vector_t, s: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rc_matrix_t {
pub rows: ::std::os::raw::c_int,
pub cols: ::std::os::raw::c_int,
pub d: *mut *mut f64,
pub initialized: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_rc_matrix_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_matrix_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_matrix_t>(),
16usize,
concat!("Size of: ", stringify!(rc_matrix_t))
);
assert_eq!(
::std::mem::align_of::<rc_matrix_t>(),
4usize,
concat!("Alignment of ", stringify!(rc_matrix_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rows) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_matrix_t), "::", stringify!(rows))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cols) as usize - ptr as usize },
4usize,
concat!("Offset of field: ", stringify!(rc_matrix_t), "::", stringify!(cols))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(rc_matrix_t), "::", stringify!(d))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(rc_matrix_t),
"::",
stringify!(initialized)
)
);
}
impl Default for rc_matrix_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn rc_matrix_empty() -> rc_matrix_t;
}
extern "C" {
pub fn rc_matrix_alloc(
A: *mut rc_matrix_t,
rows: ::std::os::raw::c_int,
cols: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_free(A: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_zeros(
A: *mut rc_matrix_t,
rows: ::std::os::raw::c_int,
cols: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_identity(A: *mut rc_matrix_t, dim: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_random(
A: *mut rc_matrix_t,
rows: ::std::os::raw::c_int,
cols: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_diagonal(A: *mut rc_matrix_t, v: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_duplicate(A: rc_matrix_t, B: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_print(A: rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_print_sci(A: rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_zero_out(A: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_times_scalar(A: *mut rc_matrix_t, s: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_multiply(A: rc_matrix_t, B: rc_matrix_t, C: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_left_multiply_inplace(A: rc_matrix_t, B: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_right_multiply_inplace(A: *mut rc_matrix_t, B: rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_add(A: rc_matrix_t, B: rc_matrix_t, C: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_add_inplace(A: *mut rc_matrix_t, B: rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_subtract_inplace(A: *mut rc_matrix_t, B: rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_transpose(A: rc_matrix_t, T: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_transpose_inplace(A: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_times_col_vec(A: rc_matrix_t, v: rc_vector_t, c: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_row_vec_times_matrix(v: rc_vector_t, A: rc_matrix_t, c: *mut rc_vector_t)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_outer_product(v1: rc_vector_t, v2: rc_vector_t, A: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_matrix_determinant(A: rc_matrix_t) -> f64;
}
extern "C" {
pub fn rc_matrix_symmetrize(P: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_lup_decomp(
A: rc_matrix_t,
L: *mut rc_matrix_t,
U: *mut rc_matrix_t,
P: *mut rc_matrix_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_qr_decomp(A: rc_matrix_t, Q: *mut rc_matrix_t, R: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_invert_matrix(A: rc_matrix_t, Ainv: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_invert_matrix_inplace(A: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_lin_system_solve(A: rc_matrix_t, b: rc_vector_t, x: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_set_zero_tolerance(tol: f64);
}
extern "C" {
pub fn rc_algebra_lin_system_solve_qr(A: rc_matrix_t, b: rc_vector_t, x: *mut rc_vector_t)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_algebra_fit_ellipsoid(
points: rc_matrix_t,
center: *mut rc_vector_t,
lengths: *mut rc_vector_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rc_ringbuf_t {
pub d: *mut f64,
pub size: ::std::os::raw::c_int,
pub index: ::std::os::raw::c_int,
pub initialized: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_rc_ringbuf_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_ringbuf_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_ringbuf_t>(),
16usize,
concat!("Size of: ", stringify!(rc_ringbuf_t))
);
assert_eq!(
::std::mem::align_of::<rc_ringbuf_t>(),
4usize,
concat!("Alignment of ", stringify!(rc_ringbuf_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_ringbuf_t), "::", stringify!(d))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!("Offset of field: ", stringify!(rc_ringbuf_t), "::", stringify!(size))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(rc_ringbuf_t), "::", stringify!(index))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(rc_ringbuf_t),
"::",
stringify!(initialized)
)
);
}
impl Default for rc_ringbuf_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn rc_ringbuf_empty() -> rc_ringbuf_t;
}
extern "C" {
pub fn rc_ringbuf_alloc(buf: *mut rc_ringbuf_t, size: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_ringbuf_free(buf: *mut rc_ringbuf_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_ringbuf_reset(buf: *mut rc_ringbuf_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_ringbuf_insert(buf: *mut rc_ringbuf_t, val: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_ringbuf_get_value(buf: *mut rc_ringbuf_t, position: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rc_ringbuf_std_dev(buf: rc_ringbuf_t) -> f64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rc_filter_t {
pub order: ::std::os::raw::c_int,
pub dt: f64,
pub gain: f64,
pub num: rc_vector_t,
pub den: rc_vector_t,
pub sat_en: ::std::os::raw::c_int,
pub sat_min: f64,
pub sat_max: f64,
pub sat_flag: ::std::os::raw::c_int,
pub ss_en: ::std::os::raw::c_int,
pub ss_steps: f64,
pub in_buf: rc_ringbuf_t,
pub out_buf: rc_ringbuf_t,
pub newest_input: f64,
pub newest_output: f64,
pub step: u64,
pub initialized: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_rc_filter_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_filter_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_filter_t>(),
152usize,
concat!("Size of: ", stringify!(rc_filter_t))
);
assert_eq!(
::std::mem::align_of::<rc_filter_t>(),
8usize,
concat!("Alignment of ", stringify!(rc_filter_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(order))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dt) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(dt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gain) as usize - ptr as usize },
16usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(gain))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num) as usize - ptr as usize },
24usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(num))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).den) as usize - ptr as usize },
36usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(den))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sat_en) as usize - ptr as usize },
48usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(sat_en))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sat_min) as usize - ptr as usize },
56usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(sat_min))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sat_max) as usize - ptr as usize },
64usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(sat_max))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sat_flag) as usize - ptr as usize },
72usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(sat_flag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ss_en) as usize - ptr as usize },
76usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(ss_en))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ss_steps) as usize - ptr as usize },
80usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(ss_steps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_buf) as usize - ptr as usize },
88usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(in_buf))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).out_buf) as usize - ptr as usize },
104usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(out_buf))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).newest_input) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(rc_filter_t),
"::",
stringify!(newest_input)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).newest_output) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(rc_filter_t),
"::",
stringify!(newest_output)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
136usize,
concat!("Offset of field: ", stringify!(rc_filter_t), "::", stringify!(step))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(rc_filter_t),
"::",
stringify!(initialized)
)
);
}
impl Default for rc_filter_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn rc_filter_empty() -> rc_filter_t;
}
extern "C" {
pub fn rc_filter_alloc(f: *mut rc_filter_t, num: rc_vector_t, den: rc_vector_t, dt: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_alloc_from_arrays(
f: *mut rc_filter_t,
dt: f64,
num: *mut f64,
numlen: ::std::os::raw::c_int,
den: *mut f64,
denlen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_duplicate(f: *mut rc_filter_t, old: rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_free(f: *mut rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_print(f: rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_march(f: *mut rc_filter_t, new_input: f64) -> f64;
}
extern "C" {
pub fn rc_filter_reset(f: *mut rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_enable_saturation(f: *mut rc_filter_t, min: f64, max: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_get_saturation_flag(f: *mut rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_enable_soft_start(f: *mut rc_filter_t, seconds: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_previous_input(f: *mut rc_filter_t, steps: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rc_filter_previous_output(f: *mut rc_filter_t, steps: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn rc_filter_prefill_inputs(f: *mut rc_filter_t, in_: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_prefill_outputs(f: *mut rc_filter_t, out: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_multiply(f1: rc_filter_t, f2: rc_filter_t, out: *mut rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_multiply_three(
f1: rc_filter_t,
f2: rc_filter_t,
f3: rc_filter_t,
out: *mut rc_filter_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_c2d_tustin(
f: *mut rc_filter_t,
dt: f64,
num: rc_vector_t,
den: rc_vector_t,
w: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_normalize(f: *mut rc_filter_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_first_order_lowpass(f: *mut rc_filter_t, dt: f64, tc: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_first_order_highpass(f: *mut rc_filter_t, dt: f64, tc: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_butterworth_lowpass(
f: *mut rc_filter_t,
order: ::std::os::raw::c_int,
dt: f64,
wc: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_butterworth_highpass(
f: *mut rc_filter_t,
order: ::std::os::raw::c_int,
dt: f64,
wc: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_moving_average(
f: *mut rc_filter_t,
samples: ::std::os::raw::c_int,
dt: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_integrator(f: *mut rc_filter_t, dt: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_double_integrator(f: *mut rc_filter_t, dt: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_pid(f: *mut rc_filter_t, kp: f64, ki: f64, kd: f64, Tf: f64, dt: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_filter_third_order_complement(
lp: *mut rc_filter_t,
hp: *mut rc_filter_t,
freq: f64,
damp: f64,
dt: f64,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rc_kalman_t {
pub F: rc_matrix_t,
pub G: rc_matrix_t,
pub H: rc_matrix_t,
pub Q: rc_matrix_t,
pub R: rc_matrix_t,
pub P: rc_matrix_t,
pub Pi: rc_matrix_t,
pub x_est: rc_vector_t,
pub x_pre: rc_vector_t,
pub initialized: ::std::os::raw::c_int,
pub step: u64,
}
#[test]
fn bindgen_test_layout_rc_kalman_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_kalman_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_kalman_t>(),
152usize,
concat!("Size of: ", stringify!(rc_kalman_t))
);
assert_eq!(
::std::mem::align_of::<rc_kalman_t>(),
8usize,
concat!("Alignment of ", stringify!(rc_kalman_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).F) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(F))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize },
16usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(G))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize },
32usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(H))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Q) as usize - ptr as usize },
48usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(Q))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).R) as usize - ptr as usize },
64usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(R))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).P) as usize - ptr as usize },
80usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(P))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Pi) as usize - ptr as usize },
96usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(Pi))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_est) as usize - ptr as usize },
112usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(x_est))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_pre) as usize - ptr as usize },
124usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(x_pre))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(rc_kalman_t),
"::",
stringify!(initialized)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
144usize,
concat!("Offset of field: ", stringify!(rc_kalman_t), "::", stringify!(step))
);
}
impl Default for rc_kalman_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn rc_kalman_empty() -> rc_kalman_t;
}
extern "C" {
pub fn rc_kalman_alloc_lin(
kf: *mut rc_kalman_t,
F: rc_matrix_t,
G: rc_matrix_t,
H: rc_matrix_t,
Q: rc_matrix_t,
R: rc_matrix_t,
Pi: rc_matrix_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_kalman_alloc_ekf(
kf: *mut rc_kalman_t,
Q: rc_matrix_t,
R: rc_matrix_t,
Pi: rc_matrix_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_kalman_free(kf: *mut rc_kalman_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_kalman_reset(kf: *mut rc_kalman_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_kalman_update_lin(kf: *mut rc_kalman_t, u: rc_vector_t, y: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_kalman_update_ekf(
kf: *mut rc_kalman_t,
F: rc_matrix_t,
H: rc_matrix_t,
x_pre: rc_vector_t,
y: rc_vector_t,
h: rc_vector_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_get_random_float() -> f32;
}
extern "C" {
pub fn rc_get_random_double() -> f64;
}
extern "C" {
pub fn rc_saturate_float(val: *mut f32, min: f32, max: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_saturate_double(val: *mut f64, min: f64, max: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_print(v: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_conv(a: rc_vector_t, b: rc_vector_t, c: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_power(a: rc_vector_t, n: ::std::os::raw::c_int, b: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_add(a: rc_vector_t, b: rc_vector_t, c: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_add_inplace(a: *mut rc_vector_t, b: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_subtract(a: rc_vector_t, b: rc_vector_t, c: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_subtract_inplace(a: *mut rc_vector_t, b: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_differentiate(
a: rc_vector_t,
d: ::std::os::raw::c_int,
b: *mut rc_vector_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_divide(
n: rc_vector_t,
d: rc_vector_t,
div: *mut rc_vector_t,
rem: *mut rc_vector_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_poly_butter(N: ::std::os::raw::c_int, wc: f64, b: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_norm(q: rc_vector_t) -> f64;
}
extern "C" {
pub fn rc_quaternion_norm_array(q: *mut f64) -> f64;
}
extern "C" {
pub fn rc_normalize_quaternion(q: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_normalize_quaternion_array(q: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_to_tb(q: rc_vector_t, tb: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_to_tb_array(q: *mut f64, tb: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_from_tb(tb: rc_vector_t, q: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_from_tb_array(tb: *mut f64, q: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_conjugate(q: rc_vector_t, c: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_conjugate_inplace(q: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_conjugate_array(q: *mut f64, c: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_conjugate_array_inplace(q: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_imaginary_part(q: rc_vector_t, img: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_multiply(a: rc_vector_t, b: rc_vector_t, c: *mut rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_multiply_array(a: *mut f64, b: *mut f64, c: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_rotate(p: *mut rc_vector_t, q: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_rotate_array(p: *mut f64, q: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_rotate_vector(v: *mut rc_vector_t, q: rc_vector_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_rotate_vector_array(v: *mut f64, q: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_quaternion_to_rotation_matrix(q: rc_vector_t, m: *mut rc_matrix_t) -> ::std::os::raw::c_int;
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct __mavlink_message {
pub checksum: u16,
pub magic: u8,
pub len: u8,
pub incompat_flags: u8,
pub compat_flags: u8,
pub seq: u8,
pub sysid: u8,
pub compid: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
pub payload64: [u64; 33usize],
pub ck: [u8; 2usize],
pub signature: [u8; 13usize],
}
#[test]
fn bindgen_test_layout___mavlink_message() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_message> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_message>(),
291usize,
concat!("Size of: ", stringify!(__mavlink_message))
);
assert_eq!(
::std::mem::align_of::<__mavlink_message>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_message))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).checksum) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(checksum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(magic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).incompat_flags) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(incompat_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compat_flags) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(compat_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).seq) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sysid) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(sysid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compid) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(compid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).payload64) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(payload64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ck) as usize - ptr as usize },
276usize,
concat!("Offset of field: ", stringify!(__mavlink_message), "::", stringify!(ck))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).signature) as usize - ptr as usize },
278usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_message),
"::",
stringify!(signature)
)
);
}
impl Default for __mavlink_message {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl __mavlink_message {
#[inline]
pub fn msgid(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
}
#[inline]
pub fn set_msgid(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 24u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(msgid: u32) -> __BindgenBitfieldUnit<[u8; 3usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 24u8, {
let msgid: u32 = unsafe { ::std::mem::transmute(msgid) };
msgid as u64
});
__bindgen_bitfield_unit
}
}
pub type mavlink_message_t = __mavlink_message;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_heartbeat_t {
pub custom_mode: u32,
pub type_: u8,
pub autopilot: u8,
pub base_mode: u8,
pub system_status: u8,
pub mavlink_version: u8,
}
#[test]
fn bindgen_test_layout___mavlink_heartbeat_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_heartbeat_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_heartbeat_t>(),
9usize,
concat!("Size of: ", stringify!(__mavlink_heartbeat_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_heartbeat_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_heartbeat_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).custom_mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_heartbeat_t),
"::",
stringify!(custom_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_heartbeat_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).autopilot) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_heartbeat_t),
"::",
stringify!(autopilot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base_mode) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_heartbeat_t),
"::",
stringify!(base_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).system_status) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_heartbeat_t),
"::",
stringify!(system_status)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mavlink_version) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_heartbeat_t),
"::",
stringify!(mavlink_version)
)
);
}
pub type mavlink_heartbeat_t = __mavlink_heartbeat_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_sys_status_t {
pub onboard_control_sensors_present: u32,
pub onboard_control_sensors_enabled: u32,
pub onboard_control_sensors_health: u32,
pub load: u16,
pub voltage_battery: u16,
pub current_battery: i16,
pub drop_rate_comm: u16,
pub errors_comm: u16,
pub errors_count1: u16,
pub errors_count2: u16,
pub errors_count3: u16,
pub errors_count4: u16,
pub battery_remaining: i8,
}
#[test]
fn bindgen_test_layout___mavlink_sys_status_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_sys_status_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_sys_status_t>(),
31usize,
concat!("Size of: ", stringify!(__mavlink_sys_status_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_sys_status_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_sys_status_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onboard_control_sensors_present) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(onboard_control_sensors_present)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onboard_control_sensors_enabled) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(onboard_control_sensors_enabled)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).onboard_control_sensors_health) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(onboard_control_sensors_health)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).load) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(load)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).voltage_battery) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(voltage_battery)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).current_battery) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(current_battery)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drop_rate_comm) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(drop_rate_comm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).errors_comm) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(errors_comm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).errors_count1) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(errors_count1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).errors_count2) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(errors_count2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).errors_count3) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(errors_count3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).errors_count4) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(errors_count4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).battery_remaining) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_sys_status_t),
"::",
stringify!(battery_remaining)
)
);
}
pub type mavlink_sys_status_t = __mavlink_sys_status_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_gps_raw_int_t {
pub time_usec: u64,
pub lat: i32,
pub lon: i32,
pub alt: i32,
pub eph: u16,
pub epv: u16,
pub vel: u16,
pub cog: u16,
pub fix_type: u8,
pub satellites_visible: u8,
pub alt_ellipsoid: i32,
pub h_acc: u32,
pub v_acc: u32,
pub vel_acc: u32,
pub hdg_acc: u32,
}
#[test]
fn bindgen_test_layout___mavlink_gps_raw_int_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_gps_raw_int_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_gps_raw_int_t>(),
50usize,
concat!("Size of: ", stringify!(__mavlink_gps_raw_int_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_gps_raw_int_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_gps_raw_int_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_usec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(time_usec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lat) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(lat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lon) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(lon)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(alt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).eph) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(eph)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).epv) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(epv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vel) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(vel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cog) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(cog)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fix_type) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(fix_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).satellites_visible) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(satellites_visible)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt_ellipsoid) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(alt_ellipsoid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_acc) as usize - ptr as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(h_acc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v_acc) as usize - ptr as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(v_acc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vel_acc) as usize - ptr as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(vel_acc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hdg_acc) as usize - ptr as usize },
46usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_gps_raw_int_t),
"::",
stringify!(hdg_acc)
)
);
}
pub type mavlink_gps_raw_int_t = __mavlink_gps_raw_int_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_scaled_pressure_t {
pub time_boot_ms: u32,
pub press_abs: f32,
pub press_diff: f32,
pub temperature: i16,
}
#[test]
fn bindgen_test_layout___mavlink_scaled_pressure_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_scaled_pressure_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_scaled_pressure_t>(),
14usize,
concat!("Size of: ", stringify!(__mavlink_scaled_pressure_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_scaled_pressure_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_scaled_pressure_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_scaled_pressure_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).press_abs) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_scaled_pressure_t),
"::",
stringify!(press_abs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).press_diff) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_scaled_pressure_t),
"::",
stringify!(press_diff)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).temperature) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_scaled_pressure_t),
"::",
stringify!(temperature)
)
);
}
pub type mavlink_scaled_pressure_t = __mavlink_scaled_pressure_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_attitude_t {
pub time_boot_ms: u32,
pub roll: f32,
pub pitch: f32,
pub yaw: f32,
pub rollspeed: f32,
pub pitchspeed: f32,
pub yawspeed: f32,
}
#[test]
fn bindgen_test_layout___mavlink_attitude_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_attitude_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_attitude_t>(),
28usize,
concat!("Size of: ", stringify!(__mavlink_attitude_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_attitude_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_attitude_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).roll) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(roll)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pitch) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(pitch)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yaw) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(yaw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rollspeed) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(rollspeed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pitchspeed) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(pitchspeed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yawspeed) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_t),
"::",
stringify!(yawspeed)
)
);
}
pub type mavlink_attitude_t = __mavlink_attitude_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_attitude_quaternion_t {
pub time_boot_ms: u32,
pub q1: f32,
pub q2: f32,
pub q3: f32,
pub q4: f32,
pub rollspeed: f32,
pub pitchspeed: f32,
pub yawspeed: f32,
}
#[test]
fn bindgen_test_layout___mavlink_attitude_quaternion_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_attitude_quaternion_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_attitude_quaternion_t>(),
32usize,
concat!("Size of: ", stringify!(__mavlink_attitude_quaternion_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_attitude_quaternion_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_attitude_quaternion_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).q1) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(q1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).q2) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(q2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).q3) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(q3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).q4) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(q4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rollspeed) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(rollspeed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pitchspeed) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(pitchspeed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yawspeed) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_attitude_quaternion_t),
"::",
stringify!(yawspeed)
)
);
}
pub type mavlink_attitude_quaternion_t = __mavlink_attitude_quaternion_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_local_position_ned_t {
pub time_boot_ms: u32,
pub x: f32,
pub y: f32,
pub z: f32,
pub vx: f32,
pub vy: f32,
pub vz: f32,
}
#[test]
fn bindgen_test_layout___mavlink_local_position_ned_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_local_position_ned_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_local_position_ned_t>(),
28usize,
concat!("Size of: ", stringify!(__mavlink_local_position_ned_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_local_position_ned_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_local_position_ned_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vx) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(vx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vy) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(vy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vz) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_local_position_ned_t),
"::",
stringify!(vz)
)
);
}
pub type mavlink_local_position_ned_t = __mavlink_local_position_ned_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_global_position_int_t {
pub time_boot_ms: u32,
pub lat: i32,
pub lon: i32,
pub alt: i32,
pub relative_alt: i32,
pub vx: i16,
pub vy: i16,
pub vz: i16,
pub hdg: u16,
}
#[test]
fn bindgen_test_layout___mavlink_global_position_int_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_global_position_int_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_global_position_int_t>(),
28usize,
concat!("Size of: ", stringify!(__mavlink_global_position_int_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_global_position_int_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_global_position_int_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lat) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(lat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lon) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(lon)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(alt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).relative_alt) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(relative_alt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vx) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(vx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vy) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(vy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vz) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(vz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hdg) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_global_position_int_t),
"::",
stringify!(hdg)
)
);
}
pub type mavlink_global_position_int_t = __mavlink_global_position_int_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_servo_output_raw_t {
pub time_usec: u32,
pub servo1_raw: u16,
pub servo2_raw: u16,
pub servo3_raw: u16,
pub servo4_raw: u16,
pub servo5_raw: u16,
pub servo6_raw: u16,
pub servo7_raw: u16,
pub servo8_raw: u16,
pub port: u8,
pub servo9_raw: u16,
pub servo10_raw: u16,
pub servo11_raw: u16,
pub servo12_raw: u16,
pub servo13_raw: u16,
pub servo14_raw: u16,
pub servo15_raw: u16,
pub servo16_raw: u16,
}
#[test]
fn bindgen_test_layout___mavlink_servo_output_raw_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_servo_output_raw_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_servo_output_raw_t>(),
37usize,
concat!("Size of: ", stringify!(__mavlink_servo_output_raw_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_servo_output_raw_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_servo_output_raw_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_usec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(time_usec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo1_raw) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo1_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo2_raw) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo2_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo3_raw) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo3_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo4_raw) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo4_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo5_raw) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo5_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo6_raw) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo6_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo7_raw) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo7_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo8_raw) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo8_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo9_raw) as usize - ptr as usize },
21usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo9_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo10_raw) as usize - ptr as usize },
23usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo10_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo11_raw) as usize - ptr as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo11_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo12_raw) as usize - ptr as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo12_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo13_raw) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo13_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo14_raw) as usize - ptr as usize },
31usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo14_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo15_raw) as usize - ptr as usize },
33usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo15_raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).servo16_raw) as usize - ptr as usize },
35usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_servo_output_raw_t),
"::",
stringify!(servo16_raw)
)
);
}
pub type mavlink_servo_output_raw_t = __mavlink_servo_output_raw_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_manual_control_t {
pub x: i16,
pub y: i16,
pub z: i16,
pub r: i16,
pub buttons: u16,
pub target: u8,
}
#[test]
fn bindgen_test_layout___mavlink_manual_control_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_manual_control_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_manual_control_t>(),
11usize,
concat!("Size of: ", stringify!(__mavlink_manual_control_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_manual_control_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_manual_control_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_manual_control_t),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_manual_control_t),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_manual_control_t),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_manual_control_t),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buttons) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_manual_control_t),
"::",
stringify!(buttons)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_manual_control_t),
"::",
stringify!(target)
)
);
}
pub type mavlink_manual_control_t = __mavlink_manual_control_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_set_position_target_local_ned_t {
pub time_boot_ms: u32,
pub x: f32,
pub y: f32,
pub z: f32,
pub vx: f32,
pub vy: f32,
pub vz: f32,
pub afx: f32,
pub afy: f32,
pub afz: f32,
pub yaw: f32,
pub yaw_rate: f32,
pub type_mask: u16,
pub target_system: u8,
pub target_component: u8,
pub coordinate_frame: u8,
}
#[test]
fn bindgen_test_layout___mavlink_set_position_target_local_ned_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_set_position_target_local_ned_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_set_position_target_local_ned_t>(),
53usize,
concat!("Size of: ", stringify!(__mavlink_set_position_target_local_ned_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_set_position_target_local_ned_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_set_position_target_local_ned_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vx) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(vx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vy) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(vy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vz) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(vz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).afx) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(afx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).afy) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(afy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).afz) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(afz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yaw) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(yaw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yaw_rate) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(yaw_rate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_mask) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(type_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target_system) as usize - ptr as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(target_system)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target_component) as usize - ptr as usize },
51usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(target_component)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).coordinate_frame) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_local_ned_t),
"::",
stringify!(coordinate_frame)
)
);
}
pub type mavlink_set_position_target_local_ned_t = __mavlink_set_position_target_local_ned_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_set_position_target_global_int_t {
pub time_boot_ms: u32,
pub lat_int: i32,
pub lon_int: i32,
pub alt: f32,
pub vx: f32,
pub vy: f32,
pub vz: f32,
pub afx: f32,
pub afy: f32,
pub afz: f32,
pub yaw: f32,
pub yaw_rate: f32,
pub type_mask: u16,
pub target_system: u8,
pub target_component: u8,
pub coordinate_frame: u8,
}
#[test]
fn bindgen_test_layout___mavlink_set_position_target_global_int_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_set_position_target_global_int_t> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_set_position_target_global_int_t>(),
53usize,
concat!("Size of: ", stringify!(__mavlink_set_position_target_global_int_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_set_position_target_global_int_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_set_position_target_global_int_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_boot_ms) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(time_boot_ms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lat_int) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(lat_int)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lon_int) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(lon_int)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(alt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vx) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(vx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vy) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(vy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vz) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(vz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).afx) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(afx)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).afy) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(afy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).afz) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(afz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yaw) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(yaw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).yaw_rate) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(yaw_rate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_mask) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(type_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target_system) as usize - ptr as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(target_system)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target_component) as usize - ptr as usize },
51usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(target_component)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).coordinate_frame) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_set_position_target_global_int_t),
"::",
stringify!(coordinate_frame)
)
);
}
pub type mavlink_set_position_target_global_int_t = __mavlink_set_position_target_global_int_t;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __mavlink_att_pos_mocap_t {
pub time_usec: u64,
pub q: [f32; 4usize],
pub x: f32,
pub y: f32,
pub z: f32,
}
#[test]
fn bindgen_test_layout___mavlink_att_pos_mocap_t() {
const UNINIT: ::std::mem::MaybeUninit<__mavlink_att_pos_mocap_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__mavlink_att_pos_mocap_t>(),
36usize,
concat!("Size of: ", stringify!(__mavlink_att_pos_mocap_t))
);
assert_eq!(
::std::mem::align_of::<__mavlink_att_pos_mocap_t>(),
1usize,
concat!("Alignment of ", stringify!(__mavlink_att_pos_mocap_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time_usec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_att_pos_mocap_t),
"::",
stringify!(time_usec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).q) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_att_pos_mocap_t),
"::",
stringify!(q)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_att_pos_mocap_t),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_att_pos_mocap_t),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__mavlink_att_pos_mocap_t),
"::",
stringify!(z)
)
);
}
pub type mavlink_att_pos_mocap_t = __mavlink_att_pos_mocap_t;
extern "C" {
pub fn rc_mav_send_heartbeat_abbreviated() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_heartbeat(
custom_mode: u32,
type_: u8,
autopilot: u8,
base_mode: u8,
system_status: u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_heartbeat(data: *mut mavlink_heartbeat_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_attitude(
roll: f32,
pitch: f32,
yaw: f32,
rollspeed: f32,
pitchspeed: f32,
yawspeed: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_attitude(data: *mut mavlink_attitude_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_attitude_quaternion(
q1: f32,
q2: f32,
q3: f32,
q4: f32,
rollspeed: f32,
pitchspeed: f32,
yawspeed: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_attitude_quaternion(data: *mut mavlink_attitude_quaternion_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_local_position_ned(x: f32, y: f32, z: f32, vx: f32, vy: f32, vz: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_local_position_ned(data: *mut mavlink_local_position_ned_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_global_position_int(
lat: i32,
lon: i32,
alt: i32,
relative_alt: i32,
vx: i16,
vy: i16,
vz: i16,
hdg: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_global_position_int(data: *mut mavlink_global_position_int_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_set_position_target_local_ned(
x: f32,
y: f32,
z: f32,
vx: f32,
vy: f32,
vz: f32,
afx: f32,
afy: f32,
afz: f32,
yaw: f32,
yaw_rate: f32,
type_mask: u16,
target_system: u8,
target_component: u8,
coordinate_frame: u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_set_position_target_local_ned(
data: *mut mavlink_set_position_target_local_ned_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_set_position_target_global_int(
lat_int: i32,
lon_int: i32,
alt: f32,
vx: f32,
vy: f32,
vz: f32,
afx: f32,
afy: f32,
afz: f32,
yaw: f32,
yaw_rate: f32,
type_mask: u16,
target_system: u8,
target_component: u8,
coordinate_frame: u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_set_position_target_global_int(
data: *mut mavlink_set_position_target_global_int_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_gps_raw_int(
lat: i32,
lon: i32,
alt: i32,
eph: u16,
epv: u16,
vel: u16,
cog: u16,
fix_type: u8,
satellites_visible: u8,
alt_ellipsoid: i32,
h_acc: u32,
v_acc: u32,
vel_acc: u32,
hdg_acc: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_gps_raw_int(data: *mut mavlink_gps_raw_int_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_scaled_pressure(press_abs: f32, press_diff: f32, temperature: i16) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_scaled_pressure(data: *mut mavlink_scaled_pressure_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_servo_output_raw(
servo1_raw: u16,
servo2_raw: u16,
servo3_raw: u16,
servo4_raw: u16,
servo5_raw: u16,
servo6_raw: u16,
servo7_raw: u16,
servo8_raw: u16,
port: u8,
servo9_raw: u16,
servo10_raw: u16,
servo11_raw: u16,
servo12_raw: u16,
servo13_raw: u16,
servo14_raw: u16,
servo15_raw: u16,
servo16_raw: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_servo_output_raw(data: *mut mavlink_servo_output_raw_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_sys_status(
onboard_control_sensors_present: u32,
onboard_control_sensors_enabled: u32,
onboard_control_sensors_health: u32,
load: u16,
voltage_battery: u16,
current_battery: i16,
drop_rate_comm: u16,
errors_comm: u16,
errors_count1: u16,
errors_count2: u16,
errors_count3: u16,
errors_count4: u16,
battery_remaining: i8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_sys_status(data: *mut mavlink_sys_status_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_manual_control(
x: i16,
y: i16,
z: i16,
r: i16,
buttons: u16,
target: u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_manual_control(data: *mut mavlink_manual_control_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_att_pos_mocap(q: *mut f32, x: f32, y: f32, z: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_att_pos_mocap(data: *mut mavlink_att_pos_mocap_t) -> ::std::os::raw::c_int;
}
pub const MAV_CONNECTION_WAITING: rc_mav_connection_state_t = 0;
pub const MAV_CONNECTION_ACTIVE: rc_mav_connection_state_t = 1;
pub const MAV_CONNECTION_LOST: rc_mav_connection_state_t = 2;
pub type rc_mav_connection_state_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_mav_init(
system_id: u8,
dest_ip: *const ::std::os::raw::c_char,
port: u16,
connection_timeout_us: u64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_set_dest_ip(dest_ip: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_set_system_id(system_id: u8) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_send_msg(msg: mavlink_message_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_is_new_msg(msg_id: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_msg(msg_id: ::std::os::raw::c_int, msg: *mut mavlink_message_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_set_callback(
msg_id: ::std::os::raw::c_int,
func: ::std::option::Option<unsafe extern "C" fn()>,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_set_callback_all(func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_set_callback_connection_lost(
func: ::std::option::Option<unsafe extern "C" fn()>,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_get_connection_state() -> rc_mav_connection_state_t;
}
extern "C" {
pub fn rc_mav_get_sys_id_of_last_msg(msg_id: ::std::os::raw::c_int) -> u8;
}
extern "C" {
pub fn rc_mav_get_sys_id_of_last_msg_any() -> u8;
}
extern "C" {
pub fn rc_mav_ns_since_last_msg(msg_id: ::std::os::raw::c_int) -> i64;
}
extern "C" {
pub fn rc_mav_ns_since_last_msg_any() -> i64;
}
extern "C" {
pub fn rc_mav_msg_id_of_last_msg() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mav_print_msg_name(msg_id: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub const MODEL_UNKNOWN: rc_model_t = 0;
pub const MODEL_BB_BLACK: rc_model_t = 1;
pub const MODEL_BB_BLACK_RC: rc_model_t = 2;
pub const MODEL_BB_BLACK_W: rc_model_t = 3;
pub const MODEL_BB_BLACK_W_RC: rc_model_t = 4;
pub const MODEL_BB_GREEN: rc_model_t = 5;
pub const MODEL_BB_GREEN_W: rc_model_t = 6;
pub const MODEL_BB_BLUE: rc_model_t = 7;
pub const MODEL_BB_POCKET: rc_model_t = 8;
pub const MODEL_RPI_B: rc_model_t = 9;
pub const MODEL_RPI_B_PLUS: rc_model_t = 10;
pub const MODEL_RPI2_B: rc_model_t = 11;
pub const MODEL_RPI3_B: rc_model_t = 12;
pub const MODEL_RPI3_B_PLUS: rc_model_t = 13;
pub const MODEL_RPI0: rc_model_t = 14;
pub const MODEL_RPI0_W: rc_model_t = 15;
pub const MODEL_RPI_CM: rc_model_t = 16;
pub const MODEL_RPI_CM3: rc_model_t = 17;
pub const MODEL_PC: rc_model_t = 18;
pub type rc_model_t = ::std::os::raw::c_uint;
pub const CATEGORY_UNKNOWN: rc_model_category_t = 0;
pub const CATEGORY_BEAGLEBONE: rc_model_category_t = 1;
pub const CATEGORY_RPI: rc_model_category_t = 2;
pub const CATEGORY_PC: rc_model_category_t = 3;
pub type rc_model_category_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_model() -> rc_model_t;
}
extern "C" {
pub fn rc_model_category() -> rc_model_category_t;
}
extern "C" {
pub fn rc_model_print();
}
extern "C" {
pub fn rc_model_category_print();
}
extern "C" {
pub fn rc_motor_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_motor_init_freq(pwm_frequency_hz: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_motor_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_motor_standby(standby_en: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_motor_set(ch: ::std::os::raw::c_int, duty: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_motor_free_spin(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_motor_brake(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub type time_t = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timespec {
pub tv_sec: time_t,
pub tv_nsec: ::std::os::raw::c_long,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_timespec() {
const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timespec>(),
16usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
8usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(timespec), "::", stringify!(tv_sec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(timespec), "::", stringify!(tv_nsec))
);
}
impl timespec {
#[inline]
pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread {
_unused: [u8; 0],
}
pub type pthread_t = *mut __pthread;
pub const ACCEL_FSR_2G: rc_mpu_accel_fsr_t = 0;
pub const ACCEL_FSR_4G: rc_mpu_accel_fsr_t = 1;
pub const ACCEL_FSR_8G: rc_mpu_accel_fsr_t = 2;
pub const ACCEL_FSR_16G: rc_mpu_accel_fsr_t = 3;
pub type rc_mpu_accel_fsr_t = ::std::os::raw::c_uint;
pub const GYRO_FSR_250DPS: rc_mpu_gyro_fsr_t = 0;
pub const GYRO_FSR_500DPS: rc_mpu_gyro_fsr_t = 1;
pub const GYRO_FSR_1000DPS: rc_mpu_gyro_fsr_t = 2;
pub const GYRO_FSR_2000DPS: rc_mpu_gyro_fsr_t = 3;
pub type rc_mpu_gyro_fsr_t = ::std::os::raw::c_uint;
pub const ACCEL_DLPF_OFF: rc_mpu_accel_dlpf_t = 0;
pub const ACCEL_DLPF_460: rc_mpu_accel_dlpf_t = 1;
pub const ACCEL_DLPF_184: rc_mpu_accel_dlpf_t = 2;
pub const ACCEL_DLPF_92: rc_mpu_accel_dlpf_t = 3;
pub const ACCEL_DLPF_41: rc_mpu_accel_dlpf_t = 4;
pub const ACCEL_DLPF_20: rc_mpu_accel_dlpf_t = 5;
pub const ACCEL_DLPF_10: rc_mpu_accel_dlpf_t = 6;
pub const ACCEL_DLPF_5: rc_mpu_accel_dlpf_t = 7;
pub type rc_mpu_accel_dlpf_t = ::std::os::raw::c_uint;
pub const GYRO_DLPF_OFF: rc_mpu_gyro_dlpf_t = 0;
pub const GYRO_DLPF_250: rc_mpu_gyro_dlpf_t = 1;
pub const GYRO_DLPF_184: rc_mpu_gyro_dlpf_t = 2;
pub const GYRO_DLPF_92: rc_mpu_gyro_dlpf_t = 3;
pub const GYRO_DLPF_41: rc_mpu_gyro_dlpf_t = 4;
pub const GYRO_DLPF_20: rc_mpu_gyro_dlpf_t = 5;
pub const GYRO_DLPF_10: rc_mpu_gyro_dlpf_t = 6;
pub const GYRO_DLPF_5: rc_mpu_gyro_dlpf_t = 7;
pub type rc_mpu_gyro_dlpf_t = ::std::os::raw::c_uint;
pub const ORIENTATION_Z_UP: rc_mpu_orientation_t = 136;
pub const ORIENTATION_Z_DOWN: rc_mpu_orientation_t = 396;
pub const ORIENTATION_X_UP: rc_mpu_orientation_t = 14;
pub const ORIENTATION_X_DOWN: rc_mpu_orientation_t = 266;
pub const ORIENTATION_Y_UP: rc_mpu_orientation_t = 112;
pub const ORIENTATION_Y_DOWN: rc_mpu_orientation_t = 336;
pub const ORIENTATION_X_FORWARD: rc_mpu_orientation_t = 133;
pub const ORIENTATION_X_BACK: rc_mpu_orientation_t = 161;
pub type rc_mpu_orientation_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rc_mpu_config_t {
pub gpio_interrupt_pin_chip: ::std::os::raw::c_int,
pub gpio_interrupt_pin: ::std::os::raw::c_int,
pub i2c_bus: ::std::os::raw::c_int,
pub i2c_addr: u8,
pub show_warnings: ::std::os::raw::c_int,
pub accel_fsr: rc_mpu_accel_fsr_t,
pub gyro_fsr: rc_mpu_gyro_fsr_t,
pub accel_dlpf: rc_mpu_accel_dlpf_t,
pub gyro_dlpf: rc_mpu_gyro_dlpf_t,
pub enable_magnetometer: ::std::os::raw::c_int,
pub dmp_sample_rate: ::std::os::raw::c_int,
pub dmp_fetch_accel_gyro: ::std::os::raw::c_int,
pub dmp_auto_calibrate_gyro: ::std::os::raw::c_int,
pub orient: rc_mpu_orientation_t,
pub compass_time_constant: f64,
pub dmp_interrupt_sched_policy: ::std::os::raw::c_int,
pub dmp_interrupt_priority: ::std::os::raw::c_int,
pub read_mag_after_callback: ::std::os::raw::c_int,
pub mag_sample_rate_div: ::std::os::raw::c_int,
pub tap_threshold: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_rc_mpu_config_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_mpu_config_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_mpu_config_t>(),
88usize,
concat!("Size of: ", stringify!(rc_mpu_config_t))
);
assert_eq!(
::std::mem::align_of::<rc_mpu_config_t>(),
8usize,
concat!("Alignment of ", stringify!(rc_mpu_config_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gpio_interrupt_pin_chip) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(gpio_interrupt_pin_chip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gpio_interrupt_pin) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(gpio_interrupt_pin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i2c_bus) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(i2c_bus)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i2c_addr) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(i2c_addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_warnings) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(show_warnings)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel_fsr) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(accel_fsr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gyro_fsr) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(gyro_fsr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel_dlpf) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(accel_dlpf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gyro_dlpf) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(gyro_dlpf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).enable_magnetometer) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(enable_magnetometer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_sample_rate) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(dmp_sample_rate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_fetch_accel_gyro) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(dmp_fetch_accel_gyro)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_auto_calibrate_gyro) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(dmp_auto_calibrate_gyro)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).orient) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(orient)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compass_time_constant) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(compass_time_constant)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_interrupt_sched_policy) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(dmp_interrupt_sched_policy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_interrupt_priority) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(dmp_interrupt_priority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_mag_after_callback) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(read_mag_after_callback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mag_sample_rate_div) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(mag_sample_rate_div)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tap_threshold) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_config_t),
"::",
stringify!(tap_threshold)
)
);
}
impl Default for rc_mpu_config_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct rc_mpu_data_t {
pub accel: [f64; 3usize],
pub gyro: [f64; 3usize],
pub mag: [f64; 3usize],
pub temp: f64,
pub raw_gyro: [i16; 3usize],
pub raw_accel: [i16; 3usize],
pub accel_to_ms2: f64,
pub gyro_to_degs: f64,
pub dmp_quat: [f64; 4usize],
pub dmp_TaitBryan: [f64; 3usize],
pub tap_detected: ::std::os::raw::c_int,
pub last_tap_direction: ::std::os::raw::c_int,
pub last_tap_count: ::std::os::raw::c_int,
pub fused_quat: [f64; 4usize],
pub fused_TaitBryan: [f64; 3usize],
pub compass_heading: f64,
pub compass_heading_raw: f64,
}
#[test]
fn bindgen_test_layout_rc_mpu_data_t() {
const UNINIT: ::std::mem::MaybeUninit<rc_mpu_data_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<rc_mpu_data_t>(),
256usize,
concat!("Size of: ", stringify!(rc_mpu_data_t))
);
assert_eq!(
::std::mem::align_of::<rc_mpu_data_t>(),
8usize,
concat!("Alignment of ", stringify!(rc_mpu_data_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(rc_mpu_data_t), "::", stringify!(accel))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gyro) as usize - ptr as usize },
24usize,
concat!("Offset of field: ", stringify!(rc_mpu_data_t), "::", stringify!(gyro))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mag) as usize - ptr as usize },
48usize,
concat!("Offset of field: ", stringify!(rc_mpu_data_t), "::", stringify!(mag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).temp) as usize - ptr as usize },
72usize,
concat!("Offset of field: ", stringify!(rc_mpu_data_t), "::", stringify!(temp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw_gyro) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(raw_gyro)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw_accel) as usize - ptr as usize },
86usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(raw_accel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).accel_to_ms2) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(accel_to_ms2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gyro_to_degs) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(gyro_to_degs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_quat) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(dmp_quat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dmp_TaitBryan) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(dmp_TaitBryan)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tap_detected) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(tap_detected)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_tap_direction) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(last_tap_direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_tap_count) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(last_tap_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fused_quat) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(fused_quat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fused_TaitBryan) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(fused_TaitBryan)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compass_heading) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(compass_heading)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compass_heading_raw) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(rc_mpu_data_t),
"::",
stringify!(compass_heading_raw)
)
);
}
extern "C" {
pub fn rc_mpu_default_config() -> rc_mpu_config_t;
}
extern "C" {
pub fn rc_mpu_set_config_to_default(conf: *mut rc_mpu_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_power_off() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_initialize(data: *mut rc_mpu_data_t, conf: rc_mpu_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_read_accel(data: *mut rc_mpu_data_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_read_gyro(data: *mut rc_mpu_data_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_read_temp(data: *mut rc_mpu_data_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_read_mag(data: *mut rc_mpu_data_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_initialize_dmp(data: *mut rc_mpu_data_t, conf: rc_mpu_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_set_dmp_callback(func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_block_until_dmp_data() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_nanos_since_last_dmp_interrupt() -> i64;
}
extern "C" {
pub fn rc_mpu_set_tap_callback(
func: ::std::option::Option<
unsafe extern "C" fn(direction: ::std::os::raw::c_int, counter: ::std::os::raw::c_int),
>,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_block_until_tap() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_nanos_since_last_tap() -> i64;
}
extern "C" {
pub fn rc_mpu_calibrate_gyro_routine(conf: rc_mpu_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_calibrate_mag_routine(conf: rc_mpu_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_calibrate_accel_routine(conf: rc_mpu_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_is_gyro_calibrated() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_is_mag_calibrated() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_mpu_is_accel_calibrated() -> ::std::os::raw::c_int;
}
pub const PINMUX_GPIO: rc_pinmux_mode_t = 0;
pub const PINMUX_GPIO_PU: rc_pinmux_mode_t = 1;
pub const PINMUX_GPIO_PD: rc_pinmux_mode_t = 2;
pub const PINMUX_PWM: rc_pinmux_mode_t = 3;
pub const PINMUX_SPI: rc_pinmux_mode_t = 4;
pub const PINMUX_UART: rc_pinmux_mode_t = 5;
pub const PINMUX_CAN: rc_pinmux_mode_t = 6;
pub type rc_pinmux_mode_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_pinmux_set(pin: ::std::os::raw::c_int, mode: rc_pinmux_mode_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pinmux_set_default() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pru_start(ch: ::std::os::raw::c_int, fw_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pru_shared_mem_ptr() -> *mut u32;
}
extern "C" {
pub fn rc_pru_stop(ch: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pthread_create(
thread: *mut pthread_t,
func: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void,
>,
arg: *mut ::std::os::raw::c_void,
policy: ::std::os::raw::c_int,
priority: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pthread_timed_join(
thread: pthread_t,
retval: *mut *mut ::std::os::raw::c_void,
timeout_sec: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pthread_print_properties(thread: pthread_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pthread_set_properties_self(
policy: ::std::os::raw::c_int,
priority: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pthread_get_process_niceness() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pthread_set_process_niceness(niceness: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pwm_init(ss: ::std::os::raw::c_int, frequency: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pwm_cleanup(ss: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pwm_set_duty(ss: ::std::os::raw::c_int, ch: ::std::os::raw::c_char, duty: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_pwm_set_duty_ns(
ss: ::std::os::raw::c_int,
ch: ::std::os::raw::c_char,
duty_ns: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_cleanup();
}
extern "C" {
pub fn rc_servo_power_rail_en(en: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_set_esc_range(min: ::std::os::raw::c_int, max: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_send_pulse_us(ch: ::std::os::raw::c_int, us: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_send_pulse_normalized(ch: ::std::os::raw::c_int, input: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_send_esc_pulse_normalized(ch: ::std::os::raw::c_int, input: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_servo_send_oneshot_pulse_normalized(ch: ::std::os::raw::c_int, input: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_init_auto_slave(
bus: ::std::os::raw::c_int,
slave: ::std::os::raw::c_int,
bus_mode: ::std::os::raw::c_int,
speed_hz: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_init_manual_slave(
bus: ::std::os::raw::c_int,
slave: ::std::os::raw::c_int,
bus_mode: ::std::os::raw::c_int,
speed_hz: ::std::os::raw::c_int,
chip: ::std::os::raw::c_int,
pin: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_get_fd(bus: ::std::os::raw::c_int, slave: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_close(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_manual_select(
bus: ::std::os::raw::c_int,
slave: ::std::os::raw::c_int,
select: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_transfer(
bus: ::std::os::raw::c_int,
slave: ::std::os::raw::c_int,
tx_data: *mut u8,
tx_bytes: usize,
rx_data: *mut u8,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_write(
bus: ::std::os::raw::c_int,
slave: ::std::os::raw::c_int,
data: *mut u8,
bytes: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_spi_read(
bus: ::std::os::raw::c_int,
slave: ::std::os::raw::c_int,
data: *mut u8,
bytes: usize,
) -> ::std::os::raw::c_int;
}
pub const UNINITIALIZED: rc_state_t = 0;
pub const RUNNING: rc_state_t = 1;
pub const PAUSED: rc_state_t = 2;
pub const EXITING: rc_state_t = 3;
pub type rc_state_t = ::std::os::raw::c_uint;
extern "C" {
pub fn rc_get_state() -> rc_state_t;
}
extern "C" {
pub fn rc_set_state(new_state: rc_state_t);
}
extern "C" {
pub fn rc_print_state() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_make_pid_file() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_kill_existing_process(timeout_s: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_remove_pid_file() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_enable_signal_handler() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_disable_signal_handler() -> ::std::os::raw::c_int;
}
pub type suseconds_t = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timeval {
pub tv_sec: time_t,
pub tv_usec: suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timeval>(),
16usize,
concat!("Size of: ", stringify!(timeval))
);
assert_eq!(
::std::mem::align_of::<timeval>(),
8usize,
concat!("Alignment of ", stringify!(timeval))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!("Offset of field: ", stringify!(timeval), "::", stringify!(tv_sec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
8usize,
concat!("Offset of field: ", stringify!(timeval), "::", stringify!(tv_usec))
);
}
extern "C" {
pub fn rc_nanosleep(ns: u64);
}
extern "C" {
pub fn rc_usleep(us: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rc_nanos_since_epoch() -> u64;
}
extern "C" {
pub fn rc_nanos_since_boot() -> u64;
}
extern "C" {
pub fn rc_nanos_thread_time() -> u64;
}
extern "C" {
pub fn rc_timespec_to_micros(ts: timespec) -> u64;
}
extern "C" {
pub fn rc_timespec_to_millis(ts: timespec) -> u64;
}
extern "C" {
pub fn rc_timeval_to_micros(tv: timeval) -> u64;
}
extern "C" {
pub fn rc_timeval_to_millis(tv: timeval) -> u64;
}
extern "C" {
pub fn rc_timespec_diff(A: timespec, B: timespec) -> timespec;
}
extern "C" {
pub fn rc_timespec_add(start: *mut timespec, seconds: f64);
}
extern "C" {
pub fn rc_uart_init(
bus: ::std::os::raw::c_int,
baudrate: ::std::os::raw::c_int,
timeout: f32,
canonical_en: ::std::os::raw::c_int,
stop_bits: ::std::os::raw::c_int,
parity_en: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_close(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_get_fd(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_flush(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_write(bus: ::std::os::raw::c_int, data: *mut u8, bytes: usize) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_read_bytes(bus: ::std::os::raw::c_int, buf: *mut u8, bytes: usize) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_read_line(bus: ::std::os::raw::c_int, buf: *mut u8, max_bytes: usize) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_uart_bytes_available(bus: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rc_version() -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rc_version_string() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn rc_version_print();
}