/* automatically generated by rust-bindgen */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    storage: Storage,
    align: [Align; 0],
}

impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn new(storage: Storage) -> Self {
        Self {
            storage,
            align: [],
        }
    }

    #[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);
        }
    }
}
 pub const HAL_kInvalidHandle : u32 = 0 ; pub const HAL_kMaxJoystickAxes : u32 = 12 ; pub const HAL_kMaxJoystickPOVs : u32 = 12 ; pub const HAL_kMaxJoysticks : u32 = 6 ; pub type HAL_Handle = i32 ; pub type HAL_PortHandle = HAL_Handle ; pub type HAL_AnalogInputHandle = HAL_Handle ; pub type HAL_AnalogOutputHandle = HAL_Handle ; pub type HAL_AnalogTriggerHandle = HAL_Handle ; pub type HAL_CompressorHandle = HAL_Handle ; pub type HAL_CounterHandle = HAL_Handle ; pub type HAL_DigitalHandle = HAL_Handle ; pub type HAL_DigitalPWMHandle = HAL_Handle ; pub type HAL_EncoderHandle = HAL_Handle ; pub type HAL_FPGAEncoderHandle = HAL_Handle ; pub type HAL_GyroHandle = HAL_Handle ; pub type HAL_InterruptHandle = HAL_Handle ; pub type HAL_NotifierHandle = HAL_Handle ; pub type HAL_RelayHandle = HAL_Handle ; pub type HAL_SolenoidHandle = HAL_Handle ; pub type HAL_CANHandle = HAL_Handle ; pub type HAL_PDPHandle = HAL_CANHandle ; pub type HAL_Bool = i32 ; pub mod HAL_AccelerometerRange { 
 /// The acceptable accelerometer ranges. 
 pub type Type = i32 ; pub const HAL_AccelerometerRange_k2G : Type = 0 ; pub const HAL_AccelerometerRange_k4G : Type = 1 ; pub const HAL_AccelerometerRange_k8G : Type = 2 ; } extern "C" { 
 /// Sets the accelerometer to active or standby mode.
///
/// It must be in standby mode to change any configuration.
///
/// @param active true to set to active, false for standby 
 pub fn HAL_SetAccelerometerActive ( active : HAL_Bool ) ; } extern "C" { 
 /// Sets the range of values that can be measured (either 2, 4, or 8 g-forces).
///
/// The accelerometer should be in standby mode when this is called.
///
/// @param range the accelerometer range 
 pub fn HAL_SetAccelerometerRange ( range : HAL_AccelerometerRange::Type ) ; } extern "C" { 
 /// Gets the x-axis acceleration.
///
/// This is a floating point value in units of 1 g-force.
///
/// @return the X acceleration 
 pub fn HAL_GetAccelerometerX ( ) -> f64 ; } extern "C" { 
 /// Gets the y-axis acceleration.
///
/// This is a floating point value in units of 1 g-force.
///
/// @return the Y acceleration 
 pub fn HAL_GetAccelerometerY ( ) -> f64 ; } extern "C" { 
 /// Gets the z-axis acceleration.
///
/// This is a floating point value in units of 1 g-force.
///
/// @return the Z acceleration 
 pub fn HAL_GetAccelerometerZ ( ) -> f64 ; } extern "C" { 
 /// Is the channel attached to an accumulator.
///
/// @param analogPortHandle Handle to the analog port.
/// @return The analog channel is attached to an accumulator. 
 pub fn HAL_IsAccumulatorChannel ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Initialize the accumulator.
///
/// @param analogPortHandle Handle to the analog port. 
 pub fn HAL_InitAccumulator ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) ; } extern "C" { 
 /// Resets the accumulator to the initial value.
///
/// @param analogPortHandle Handle to the analog port. 
 pub fn HAL_ResetAccumulator ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) ; } extern "C" { 
 /// Set the center value of the accumulator.
///
/// The center value is subtracted from each A/D value before it is added to the
/// accumulator. This is used for the center value of devices like gyros and
/// accelerometers to make integration work and to take the device offset into
/// account when integrating.
///
/// This center value is based on the output of the oversampled and averaged
/// source from channel 1. Because of this, any non-zero oversample bits will
/// affect the size of the value for this field.
///
/// @param analogPortHandle Handle to the analog port.
/// @param center The center value of the accumulator. 
 pub fn HAL_SetAccumulatorCenter ( analogPortHandle : HAL_AnalogInputHandle , center : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Set the accumulator's deadband.
///
/// @param analogPortHandle Handle to the analog port.
/// @param deadband The deadband of the accumulator. 
 pub fn HAL_SetAccumulatorDeadband ( analogPortHandle : HAL_AnalogInputHandle , deadband : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Read the accumulated value.
///
/// Read the value that has been accumulating on channel 1.
/// The accumulator is attached after the oversample and average engine.
///
/// @param analogPortHandle Handle to the analog port.
/// @return The 64-bit value accumulated since the last Reset(). 
 pub fn HAL_GetAccumulatorValue ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i64 ; } extern "C" { 
 /// Read the number of accumulated values.
///
/// Read the count of the accumulated values since the accumulator was last
/// Reset().
///
/// @param analogPortHandle Handle to the analog port.
/// @return The number of times samples from the channel were accumulated. 
 pub fn HAL_GetAccumulatorCount ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i64 ; } extern "C" { 
 /// Read the accumulated value and the number of accumulated values atomically.
///
/// This function reads the value and count from the FPGA atomically.
/// This can be used for averaging.
///
/// @param analogPortHandle Handle to the analog port.
/// @param value Pointer to the 64-bit accumulated output.
/// @param count Pointer to the number of accumulation cycles. 
 pub fn HAL_GetAccumulatorOutput ( analogPortHandle : HAL_AnalogInputHandle , value : * mut i64 , count : * mut i64 , status : * mut i32 ) ; } extern "C" { 
 /// Initializes an analog gyro.
///
/// @param handle handle to the analog port
/// @return       the initialized gyro handle 
 pub fn HAL_InitializeAnalogGyro ( handle : HAL_AnalogInputHandle , status : * mut i32 ) -> HAL_GyroHandle ; } extern "C" { 
 /// Sets up an analog gyro with the proper offsets and settings for the KOP
/// analog gyro.
///
/// @param handle the gyro handle 
 pub fn HAL_SetupAnalogGyro ( handle : HAL_GyroHandle , status : * mut i32 ) ; } extern "C" { 
 /// Frees an analog gyro.
///
/// @param handle the gyro handle 
 pub fn HAL_FreeAnalogGyro ( handle : HAL_GyroHandle ) ; } extern "C" { 
 /// Sets the analog gyro parameters to the specified values.
///
/// This is meant to be used if you want to reuse the values from a previous
/// calibration.
///
/// @param handle                  the gyro handle
/// @param voltsPerDegreePerSecond the gyro volts scaling
/// @param offset                  the gyro offset
/// @param center                  the gyro center 
 pub fn HAL_SetAnalogGyroParameters ( handle : HAL_GyroHandle , voltsPerDegreePerSecond : f64 , offset : f64 , center : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the analog gyro volts per degrees per second scaling.
///
/// @param handle                  the gyro handle
/// @param voltsPerDegreePerSecond the gyro volts scaling 
 pub fn HAL_SetAnalogGyroVoltsPerDegreePerSecond ( handle : HAL_GyroHandle , voltsPerDegreePerSecond : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Resets the analog gyro value to 0.
///
/// @param handle the gyro handle 
 pub fn HAL_ResetAnalogGyro ( handle : HAL_GyroHandle , status : * mut i32 ) ; } extern "C" { 
 /// Calibrates the analog gyro.
///
/// This happens by calculating the average value of the gyro over 5 seconds, and
/// setting that as the center. Note that this call blocks for 5 seconds to
/// perform this.
///
/// @param handle the gyro handle 
 pub fn HAL_CalibrateAnalogGyro ( handle : HAL_GyroHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets the deadband of the analog gyro.
///
/// @param handle the gyro handle
/// @param volts  the voltage deadband 
 pub fn HAL_SetAnalogGyroDeadband ( handle : HAL_GyroHandle , volts : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the gyro angle in degrees.
///
/// @param handle the gyro handle
/// @return the gyro angle in degrees 
 pub fn HAL_GetAnalogGyroAngle ( handle : HAL_GyroHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the gyro rate in degrees/second.
///
/// @param handle the gyro handle
/// @return the gyro rate in degrees/second 
 pub fn HAL_GetAnalogGyroRate ( handle : HAL_GyroHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the calibrated gyro offset.
///
/// Can be used to not repeat a calibration but reconstruct the gyro object.
///
/// @param handle the gyro handle
/// @return the gryo offset 
 pub fn HAL_GetAnalogGyroOffset ( handle : HAL_GyroHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the calibrated gyro center.
///
/// Can be used to not repeat a calibration but reconstruct the gyro object.
///
/// @param handle the gyro handle
/// @return the gyro center 
 pub fn HAL_GetAnalogGyroCenter ( handle : HAL_GyroHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Initializes the analog input port using the given port object.
///
/// @param portHandle Handle to the port to initialize.
/// @return           the created analog input handle 
 pub fn HAL_InitializeAnalogInputPort ( portHandle : HAL_PortHandle , status : * mut i32 ) -> HAL_AnalogInputHandle ; } extern "C" { 
 /// Frees an analog input port.
///
/// @param analogPortHandle Handle to the analog port. 
 pub fn HAL_FreeAnalogInputPort ( analogPortHandle : HAL_AnalogInputHandle ) ; } extern "C" { 
 /// Checks that the analog module number is valid.
///
/// @param module The analog module number.
/// @return Analog module is valid and present 
 pub fn HAL_CheckAnalogModule ( module : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Checks that the analog output channel number is value.
/// Verifies that the analog channel number is one of the legal channel numbers.
/// Channel numbers are 0-based.
///
/// @param channel The analog output channel number.
/// @return Analog channel is valid 
 pub fn HAL_CheckAnalogInputChannel ( channel : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Sets the sample rate.
///
/// This is a global setting for the Athena and effects all channels.
///
/// @param samplesPerSecond The number of samples per channel per second. 
 pub fn HAL_SetAnalogSampleRate ( samplesPerSecond : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the current sample rate.
///
/// This assumes one entry in the scan list.
/// This is a global setting for the Athena and effects all channels.
///
/// @return Sample rate. 
 pub fn HAL_GetAnalogSampleRate ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Sets the number of averaging bits.
///
/// This sets the number of averaging bits. The actual number of averaged samples
/// is 2**bits. Use averaging to improve the stability of your measurement at the
/// expense of sampling rate. The averaging is done automatically in the FPGA.
///
/// @param analogPortHandle Handle to the analog port to configure.
/// @param bits Number of bits to average. 
 pub fn HAL_SetAnalogAverageBits ( analogPortHandle : HAL_AnalogInputHandle , bits : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the number of averaging bits.
///
/// This gets the number of averaging bits from the FPGA. The actual number of
/// averaged samples is 2**bits. The averaging is done automatically in the FPGA.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return Bits to average. 
 pub fn HAL_GetAnalogAverageBits ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Sets the number of oversample bits.
///
/// This sets the number of oversample bits. The actual number of oversampled
/// values is 2**bits. Use oversampling to improve the resolution of your
/// measurements at the expense of sampling rate. The oversampling is done
/// automatically in the FPGA.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @param bits Number of bits to oversample. 
 pub fn HAL_SetAnalogOversampleBits ( analogPortHandle : HAL_AnalogInputHandle , bits : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the number of oversample bits.
///
/// This gets the number of oversample bits from the FPGA. The actual number of
/// oversampled values is 2**bits. The oversampling is done automatically in the
/// FPGA.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return Bits to oversample. 
 pub fn HAL_GetAnalogOversampleBits ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets a sample straight from the channel on this module.
///
/// The sample is a 12-bit value representing the 0V to 5V range of the A/D
/// converter in the module. The units are in A/D converter codes.  Use
/// GetVoltage() to get the analog value in calibrated units.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return A sample straight from the channel on this module. 
 pub fn HAL_GetAnalogValue ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets a sample from the output of the oversample and average engine for the
/// channel.
///
/// The sample is 12-bit + the value configured in SetOversampleBits().
/// The value configured in SetAverageBits() will cause this value to be averaged
/// 2**bits number of samples. This is not a sliding window.  The sample will not
/// change until 2**(OversamplBits + AverageBits) samples have been acquired from
/// the module on this channel. Use GetAverageVoltage() to get the analog value
/// in calibrated units.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return A sample from the oversample and average engine for the channel. 
 pub fn HAL_GetAnalogAverageValue ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Converts a voltage to a raw value for a specified channel.
///
/// This process depends on the calibration of each channel, so the channel must
/// be specified.
///
/// @todo This assumes raw values.  Oversampling not supported as is.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @param voltage The voltage to convert.
/// @return The raw value for the channel. 
 pub fn HAL_GetAnalogVoltsToValue ( analogPortHandle : HAL_AnalogInputHandle , voltage : f64 , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets a scaled sample straight from the channel on this module.
///
/// The value is scaled to units of Volts using the calibrated scaling data from
/// GetLSBWeight() and GetOffset().
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return A scaled sample straight from the channel on this module. 
 pub fn HAL_GetAnalogVoltage ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets a scaled sample from the output of the oversample and average engine for
/// the channel.
///
/// The value is scaled to units of Volts using the calibrated scaling data from
/// GetLSBWeight() and GetOffset(). Using oversampling will cause this value to
/// be higher resolution, but it will update more slowly. Using averaging will
/// cause this value to be more stable, but it will update more slowly.
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return A scaled sample from the output of the oversample and average engine
/// for the channel. 
 pub fn HAL_GetAnalogAverageVoltage ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the factory scaling least significant bit weight constant.
/// The least significant bit weight constant for the channel that was calibrated
/// in manufacturing and stored in an eeprom in the module.
///
/// Volts = ((LSB_Weight * 1e-9) * raw) - (Offset * 1e-9)
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return Least significant bit weight. 
 pub fn HAL_GetAnalogLSBWeight ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the factory scaling offset constant.
/// The offset constant for the channel that was calibrated in manufacturing and
/// stored in an eeprom in the module.
///
/// Volts = ((LSB_Weight * 1e-9) * raw) - (Offset * 1e-9)
///
/// @param analogPortHandle Handle to the analog port to use.
/// @return Offset constant. 
 pub fn HAL_GetAnalogOffset ( analogPortHandle : HAL_AnalogInputHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Initializes the analog output port using the given port object.
///
/// @param handle handle to the port
/// @return       the created analog output handle 
 pub fn HAL_InitializeAnalogOutputPort ( portHandle : HAL_PortHandle , status : * mut i32 ) -> HAL_AnalogOutputHandle ; } extern "C" { 
 /// Frees an analog output port.
///
/// @param analogOutputHandle the analog output handle 
 pub fn HAL_FreeAnalogOutputPort ( analogOutputHandle : HAL_AnalogOutputHandle ) ; } extern "C" { 
 /// Sets an analog output value.
///
/// @param analogOutputHandle the analog output handle
/// @param voltage            the voltage (0-5v) to output 
 pub fn HAL_SetAnalogOutput ( analogOutputHandle : HAL_AnalogOutputHandle , voltage : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the current analog output value.
///
/// @param analogOutputHandle the analog output handle
/// @return                   the current output voltage (0-5v) 
 pub fn HAL_GetAnalogOutput ( analogOutputHandle : HAL_AnalogOutputHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Checks that the analog output channel number is value.
///
/// Verifies that the analog channel number is one of the legal channel numbers.
/// Channel numbers are 0-based.
///
/// @return Analog channel is valid 
 pub fn HAL_CheckAnalogOutputChannel ( channel : i32 ) -> HAL_Bool ; } pub mod HAL_AnalogTriggerType { 
 /// The type of analog trigger to trigger on. 
 pub type Type = i32 ; pub const HAL_Trigger_kInWindow : Type = 0 ; pub const HAL_Trigger_kState : Type = 1 ; pub const HAL_Trigger_kRisingPulse : Type = 2 ; pub const HAL_Trigger_kFallingPulse : Type = 3 ; } extern "C" { 
 /// Initializes an analog trigger.
///
/// @param portHandle the analog input to use for triggering
/// @param index      the trigger index value (output)
/// @return           the created analog trigger handle 
 pub fn HAL_InitializeAnalogTrigger ( portHandle : HAL_AnalogInputHandle , index : * mut i32 , status : * mut i32 ) -> HAL_AnalogTriggerHandle ; } extern "C" { 
 /// Frees an analog trigger.
///
/// @param analogTriggerHandle the trigger handle 
 pub fn HAL_CleanAnalogTrigger ( analogTriggerHandle : HAL_AnalogTriggerHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets the raw ADC upper and lower limits of the analog trigger.
///
/// HAL_SetAnalogTriggerLimitsVoltage is likely better in most cases.
///
/// @param analogTriggerHandle the trigger handle
/// @param lower               the lower ADC value
/// @param upper               the upper ADC value 
 pub fn HAL_SetAnalogTriggerLimitsRaw ( analogTriggerHandle : HAL_AnalogTriggerHandle , lower : i32 , upper : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the upper and lower limits of the analog trigger.
///
/// The limits are given as floating point voltage values.
///
/// @param analogTriggerHandle the trigger handle
/// @param lower               the lower voltage value
/// @param upper               the upper voltage value 
 pub fn HAL_SetAnalogTriggerLimitsVoltage ( analogTriggerHandle : HAL_AnalogTriggerHandle , lower : f64 , upper : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Configures the analog trigger to use the averaged vs. raw values.
///
/// If the value is true, then the averaged value is selected for the analog
/// trigger, otherwise the immediate value is used.
///
/// @param analogTriggerHandle the trigger handle
/// @param useAveragedValue    true to use averaged values, false for raw 
 pub fn HAL_SetAnalogTriggerAveraged ( analogTriggerHandle : HAL_AnalogTriggerHandle , useAveragedValue : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Configures the analog trigger to use a filtered value.
///
/// The analog trigger will operate with a 3 point average rejection filter. This
/// is designed to help with 360 degree pot applications for the period where the
/// pot crosses through zero.
///
/// @param analogTriggerHandle the trigger handle
/// @param useFilteredValue    true to use filtered values, false for average or
/// raw 
 pub fn HAL_SetAnalogTriggerFiltered ( analogTriggerHandle : HAL_AnalogTriggerHandle , useFilteredValue : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Returns the InWindow output of the analog trigger.
///
/// True if the analog input is between the upper and lower limits.
///
/// @param analogTriggerHandle the trigger handle
/// @return                    the InWindow output of the analog trigger 
 pub fn HAL_GetAnalogTriggerInWindow ( analogTriggerHandle : HAL_AnalogTriggerHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Returns the TriggerState output of the analog trigger.
///
/// True if above upper limit.
/// False if below lower limit.
/// If in Hysteresis, maintain previous state.
///
/// @param analogTriggerHandle the trigger handle
/// @return                    the TriggerState output of the analog trigger 
 pub fn HAL_GetAnalogTriggerTriggerState ( analogTriggerHandle : HAL_AnalogTriggerHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the state of the analog trigger output.
///
/// @param analogTriggerHandle the trigger handle
/// @param type                the type of trigger to trigger on
/// @return                    the state of the analog trigger output 
 pub fn HAL_GetAnalogTriggerOutput ( analogTriggerHandle : HAL_AnalogTriggerHandle , type_ : HAL_AnalogTriggerType::Type , status : * mut i32 ) -> HAL_Bool ; } 
 /// Storage for CAN Stream Messages. 
 # [ repr ( C ) ] # [ derive ( Debug , Default , Copy , Clone ) ] pub struct HAL_CANStreamMessage { pub messageID : u32 , pub timeStamp : u32 , pub data : [ u8 ; 8usize ] , pub dataSize : u8 , } # [ test ] fn bindgen_test_layout_HAL_CANStreamMessage ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_CANStreamMessage > ( ) , 20usize , concat ! ( "Size of: " , stringify ! ( HAL_CANStreamMessage ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_CANStreamMessage > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( HAL_CANStreamMessage ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_CANStreamMessage > ( ) ) ) . messageID as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( HAL_CANStreamMessage ) , "::" , stringify ! ( messageID ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_CANStreamMessage > ( ) ) ) . timeStamp as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( HAL_CANStreamMessage ) , "::" , stringify ! ( timeStamp ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_CANStreamMessage > ( ) ) ) . data as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( HAL_CANStreamMessage ) , "::" , stringify ! ( data ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_CANStreamMessage > ( ) ) ) . dataSize as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( HAL_CANStreamMessage ) , "::" , stringify ! ( dataSize ) ) ) ; } extern "C" { 
 /// Initializes a compressor on the given PCM module.
///
/// @param module the module number
/// @return       the created handle 
 pub fn HAL_InitializeCompressor ( module : i32 , status : * mut i32 ) -> HAL_CompressorHandle ; } extern "C" { 
 /// Gets if a compressor module is valid.
///
/// @param module the module number
/// @return       true if the module is valid, otherwise false 
 pub fn HAL_CheckCompressorModule ( module : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the compressor state (on or off).
///
/// @param compressorHandle the compressor handle
/// @return                 true if the compressor is on, otherwise false 
 pub fn HAL_GetCompressor ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Sets the compressor to closed loop mode.
///
/// @param compressorHandle the compressor handle
/// @param value            true for closed loop mode, false for off 
 pub fn HAL_SetCompressorClosedLoopControl ( compressorHandle : HAL_CompressorHandle , value : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Gets if the compressor is in closed loop mode.
///
/// @param compressorHandle the compressor handle
/// @return                 true if the compressor is in closed loop mode,
/// otherwise false 
 pub fn HAL_GetCompressorClosedLoopControl ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the compressor pressure switch state.
///
/// @param compressorHandle the compressor handle
/// @return                 true if the pressure switch is triggered, otherwise
/// false 
 pub fn HAL_GetCompressorPressureSwitch ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the compressor current.
///
/// @param compressorHandle the compressor handle
/// @return                 the compressor current in amps 
 pub fn HAL_GetCompressorCurrent ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets if the compressor is faulted because of too high of current.
///
/// @param compressorHandle the compressor handle
/// @return                 true if falted, otherwise false 
 pub fn HAL_GetCompressorCurrentTooHighFault ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if a sticky fauly is triggered because of too high of current.
///
/// @param compressorHandle the compressor handle
/// @return                 true if falted, otherwise false 
 pub fn HAL_GetCompressorCurrentTooHighStickyFault ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if a sticky fauly is triggered because of a short.
///
/// @param compressorHandle the compressor handle
/// @return                 true if falted, otherwise false 
 pub fn HAL_GetCompressorShortedStickyFault ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if the compressor is faulted because of a short.
///
/// @param compressorHandle the compressor handle
/// @return                 true if shorted, otherwise false 
 pub fn HAL_GetCompressorShortedFault ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if a sticky fault is triggered of the compressor not connected.
///
/// @param compressorHandle the compressor handle
/// @return                 true if falted, otherwise false 
 pub fn HAL_GetCompressorNotConnectedStickyFault ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if the compressor is not connected.
///
/// @param compressorHandle the compressor handle
/// @return                 true if not connected, otherwise false 
 pub fn HAL_GetCompressorNotConnectedFault ( compressorHandle : HAL_CompressorHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the number of FPGA system clock ticks per microsecond.
///
/// @return the number of clock ticks per microsecond 
 pub fn HAL_GetSystemClockTicksPerMicrosecond ( ) -> i32 ; } pub mod HAL_Counter_Mode { 
 /// The counter mode. 
 pub type Type = i32 ; pub const HAL_Counter_kTwoPulse : Type = 0 ; pub const HAL_Counter_kSemiperiod : Type = 1 ; pub const HAL_Counter_kPulseLength : Type = 2 ; pub const HAL_Counter_kExternalDirection : Type = 3 ; } extern "C" { 
 /// Initializes a counter.
///
/// @param mode  the counter mode
/// @param index the compressor index (output)
/// @return      the created handle 
 pub fn HAL_InitializeCounter ( mode : HAL_Counter_Mode::Type , index : * mut i32 , status : * mut i32 ) -> HAL_CounterHandle ; } extern "C" { 
 /// Frees a counter.
///
/// @param counterHandle the counter handle 
 pub fn HAL_FreeCounter ( counterHandle : HAL_CounterHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets the average sample size of a counter.
///
/// @param counterHandle the counter handle
/// @param size          the size of samples to average 
 pub fn HAL_SetCounterAverageSize ( counterHandle : HAL_CounterHandle , size : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the source object that causes the counter to count up.
///
/// @param counterHandle       the counter handle
/// @param digitalSourceHandle the digital source handle (either a
/// HAL_AnalogTriggerHandle of a HAL_DigitalHandle)
/// @param analogTriggerType   the analog trigger type if the source is an analog
/// trigger 
 pub fn HAL_SetCounterUpSource ( counterHandle : HAL_CounterHandle , digitalSourceHandle : HAL_Handle , analogTriggerType : HAL_AnalogTriggerType::Type , status : * mut i32 ) ; } extern "C" { 
 /// Sets the up source to either detect rising edges or falling edges.
///
/// Note that both are allowed to be set true at the same time without issues.
///
/// @param counterHandle the counter handle
/// @param risingEdge    true to trigger on rising
/// @param fallingEdge   true to trigger on falling 
 pub fn HAL_SetCounterUpSourceEdge ( counterHandle : HAL_CounterHandle , risingEdge : HAL_Bool , fallingEdge : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Disables the up counting source to the counter.
///
/// @param counterHandle the counter handle 
 pub fn HAL_ClearCounterUpSource ( counterHandle : HAL_CounterHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets the source object that causes the counter to count down.
///
/// @param counterHandle       the counter handle
/// @param digitalSourceHandle the digital source handle (either a
/// HAL_AnalogTriggerHandle of a HAL_DigitalHandle)
/// @param analogTriggerType   the analog trigger type if the source is an analog
/// trigger 
 pub fn HAL_SetCounterDownSource ( counterHandle : HAL_CounterHandle , digitalSourceHandle : HAL_Handle , analogTriggerType : HAL_AnalogTriggerType::Type , status : * mut i32 ) ; } extern "C" { 
 /// Sets the down source to either detect rising edges or falling edges.
/// Note that both are allowed to be set true at the same time without issues.
///
/// @param counterHandle the counter handle
/// @param risingEdge    true to trigger on rising
/// @param fallingEdge   true to trigger on falling 
 pub fn HAL_SetCounterDownSourceEdge ( counterHandle : HAL_CounterHandle , risingEdge : HAL_Bool , fallingEdge : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Disables the down counting source to the counter.
///
/// @param counterHandle the counter handle 
 pub fn HAL_ClearCounterDownSource ( counterHandle : HAL_CounterHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets standard up / down counting mode on this counter.
///
/// Up and down counts are sourced independently from two inputs.
///
/// @param counterHandle the counter handle 
 pub fn HAL_SetCounterUpDownMode ( counterHandle : HAL_CounterHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets directional counting mode on this counter.
///
/// The direction is determined by the B input, with counting happening with the
/// A input.
///
/// @param counterHandle the counter handle 
 pub fn HAL_SetCounterExternalDirectionMode ( counterHandle : HAL_CounterHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets Semi-period mode on this counter.
///
/// The counter counts up based on the time the input is triggered. High or Low
/// depends on the highSemiPeriod parameter.
///
/// @param counterHandle  the counter handle
/// @param highSemiPeriod true for counting when the input is high, false for low 
 pub fn HAL_SetCounterSemiPeriodMode ( counterHandle : HAL_CounterHandle , highSemiPeriod : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Configures the counter to count in up or down based on the length of the
/// input pulse.
///
/// This mode is most useful for direction sensitive gear tooth sensors.
///
/// @param counterHandle the counter handle
/// @param threshold The pulse length beyond which the counter counts the
/// opposite direction (seconds) 
 pub fn HAL_SetCounterPulseLengthMode ( counterHandle : HAL_CounterHandle , threshold : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the Samples to Average which specifies the number of samples of the
/// timer to average when calculating the period. Perform averaging to account
/// for mechanical imperfections or as oversampling to increase resolution.
///
/// @param counterHandle the counter handle
/// @return SamplesToAverage The number of samples being averaged (from 1 to 127) 
 pub fn HAL_GetCounterSamplesToAverage ( counterHandle : HAL_CounterHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Sets the Samples to Average which specifies the number of samples of the
/// timer to average when calculating the period. Perform averaging to account
/// for mechanical imperfections or as oversampling to increase resolution.
///
/// @param counterHandle    the counter handle
/// @param samplesToAverage The number of samples to average from 1 to 127 
 pub fn HAL_SetCounterSamplesToAverage ( counterHandle : HAL_CounterHandle , samplesToAverage : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Resets the Counter to zero.
///
/// Sets the counter value to zero. This does not effect the running state of the
/// counter, just sets the current value to zero.
///
/// @param counterHandle the counter handle 
 pub fn HAL_ResetCounter ( counterHandle : HAL_CounterHandle , status : * mut i32 ) ; } extern "C" { 
 /// Reads the current counter value.
///
/// Reads the value at this instant. It may still be running, so it reflects the
/// current value. Next time it is read, it might have a different value.
///
/// @param counterHandle the counter handle
/// @return              the current counter value 
 pub fn HAL_GetCounter ( counterHandle : HAL_CounterHandle , status : * mut i32 ) -> i32 ; } extern "C" { pub fn HAL_GetCounterPeriod ( counterHandle : HAL_CounterHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Sets the maximum period where the device is still considered "moving".
///
/// Sets the maximum period where the device is considered moving. This value is
/// used to determine the "stopped" state of the counter using the
/// HAL_GetCounterStopped method.
///
/// @param counterHandle the counter handle
/// @param maxPeriod     the maximum period where the counted device is
/// considered moving in seconds 
 pub fn HAL_SetCounterMaxPeriod ( counterHandle : HAL_CounterHandle , maxPeriod : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Selects whether you want to continue updating the event timer output when
/// there are no samples captured.
///
/// The output of the event timer has a buffer of periods that are averaged and
/// posted to a register on the FPGA.  When the timer detects that the event
/// source has stopped (based on the MaxPeriod) the buffer of samples to be
/// averaged is emptied.
///
/// If you enable the update when empty, you will be
/// notified of the stopped source and the event time will report 0 samples.
///
/// If you disable update when empty, the most recent average will remain on the
/// output until a new sample is acquired.
///
/// You will never see 0 samples output (except when there have been no events
/// since an FPGA reset) and you will likely not see the stopped bit become true
/// (since it is updated at the end of an average and there are no samples to
/// average).
///
/// @param counterHandle the counter handle
/// @param enabled       true to enable counter updating with no samples 
 pub fn HAL_SetCounterUpdateWhenEmpty ( counterHandle : HAL_CounterHandle , enabled : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Determines if the clock is stopped.
///
/// Determine if the clocked input is stopped based on the MaxPeriod value set
/// using the SetMaxPeriod method. If the clock exceeds the MaxPeriod, then the
/// device (and counter) are assumed to be stopped and it returns true.
///
/// @param counterHandle the counter handle
/// @return              true if the most recent counter period exceeds the
/// MaxPeriod value set by SetMaxPeriod 
 pub fn HAL_GetCounterStopped ( counterHandle : HAL_CounterHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the last direction the counter value changed.
///
/// @param counterHandle the counter handle
/// @return              the last direction the counter value changed 
 pub fn HAL_GetCounterDirection ( counterHandle : HAL_CounterHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Sets the Counter to return reversed sensing on the direction.
///
/// This allows counters to change the direction they are counting in the case of
/// 1X and 2X quadrature encoding only. Any other counter mode isn't supported.
///
/// @param counterHandle    the counter handle
/// @param reverseDirection true if the value counted should be negated. 
 pub fn HAL_SetCounterReverseDirection ( counterHandle : HAL_CounterHandle , reverseDirection : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Creates a new instance of a digital port.
///
/// @param portHandle the port handle to create from
/// @param input      true for input, false for output
/// @return           the created digital handle 
 pub fn HAL_InitializeDIOPort ( portHandle : HAL_PortHandle , input : HAL_Bool , status : * mut i32 ) -> HAL_DigitalHandle ; } extern "C" { 
 /// Checks if a DIO channel is valid.
///
/// @param channel the channel number to check
/// @return        true if the channel is correct, otherwise false 
 pub fn HAL_CheckDIOChannel ( channel : i32 ) -> HAL_Bool ; } extern "C" { pub fn HAL_FreeDIOPort ( dioPortHandle : HAL_DigitalHandle ) ; } extern "C" { 
 /// Allocates a DO PWM Generator.
///
/// @return the allocated digital PWM handle 
 pub fn HAL_AllocateDigitalPWM ( status : * mut i32 ) -> HAL_DigitalPWMHandle ; } extern "C" { 
 /// Frees the resource associated with a DO PWM generator.
///
/// @param pwmGenerator the digital PWM handle 
 pub fn HAL_FreeDigitalPWM ( pwmGenerator : HAL_DigitalPWMHandle , status : * mut i32 ) ; } extern "C" { 
 /// Changes the frequency of the DO PWM generator.
///
/// The valid range is from 0.6 Hz to 19 kHz.
///
///  The frequency resolution is logarithmic.
///
/// @param rate the frequency to output all digital output PWM signals 
 pub fn HAL_SetDigitalPWMRate ( rate : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Configures the duty-cycle of the PWM generator.
///
/// @param pwmGenerator the digital PWM handle
/// @param dutyCycle    the percent duty cycle to output [0..1] 
 pub fn HAL_SetDigitalPWMDutyCycle ( pwmGenerator : HAL_DigitalPWMHandle , dutyCycle : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Configures which DO channel the PWM signal is output on.
///
/// @param pwmGenerator the digital PWM handle
/// @param channel      the channel to output on 
 pub fn HAL_SetDigitalPWMOutputChannel ( pwmGenerator : HAL_DigitalPWMHandle , channel : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Writes a digital value to a DIO channel.
///
/// @param dioPortHandle the digital port handle
/// @param value         the state to set the digital channel (if it is
/// configured as an output) 
 pub fn HAL_SetDIO ( dioPortHandle : HAL_DigitalHandle , value : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Sets the direction of a DIO channel.
///
/// @param dioPortHandle the digital port handle
/// @param input         true to set input, false for output 
 pub fn HAL_SetDIODirection ( dioPortHandle : HAL_DigitalHandle , input : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Reads a digital value from a DIO channel.
///
/// @param dioPortHandle the digital port handle
/// @return              the state of the specified channel 
 pub fn HAL_GetDIO ( dioPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Reads the direction of a DIO channel.
///
/// @param dioPortHandle the digital port handle
/// @return              true for input, false for output 
 pub fn HAL_GetDIODirection ( dioPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Generates a single digital pulse.
///
/// Write a pulse to the specified digital output channel. There can only be a
/// single pulse going at any time.
///
/// @param dioPortHandle the digital port handle
/// @param pulseLength   the active length of the pulse (in seconds) 
 pub fn HAL_Pulse ( dioPortHandle : HAL_DigitalHandle , pulseLength : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Checks a DIO line to see if it is currently generating a pulse.
///
/// @return true if a pulse is in progress, otherwise false 
 pub fn HAL_IsPulsing ( dioPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Checks if any DIO line is currently generating a pulse.
///
/// @return true if a pulse on some line is in progress 
 pub fn HAL_IsAnyPulsing ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Writes the filter index from the FPGA.
///
/// Set the filter index used to filter out short pulses.
///
/// @param dioPortHandle the digital port handle
/// @param filterIndex   the filter index (Must be in the range 0 - 3, where 0
/// means "none" and 1 - 3 means filter # filterIndex - 1) 
 pub fn HAL_SetFilterSelect ( dioPortHandle : HAL_DigitalHandle , filterIndex : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Reads the filter index from the FPGA.
///
/// Gets the filter index used to filter out short pulses.
///
/// @param dioPortHandle the digital port handle
/// @return filterIndex  the filter index (Must be in the range 0 - 3,
/// where 0 means "none" and 1 - 3 means filter # filterIndex - 1) 
 pub fn HAL_GetFilterSelect ( dioPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Sets the filter period for the specified filter index.
///
/// Sets the filter period in FPGA cycles.  Even though there are 2 different
/// filter index domains (MXP vs HDR), ignore that distinction for now since it
/// compilicates the interface.  That can be changed later.
///
/// @param filterIndex the filter index, 0 - 2
/// @param value       the number of cycles that the signal must not transition
/// to be counted as a transition. 
 pub fn HAL_SetFilterPeriod ( filterIndex : i32 , value : i64 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the filter period for the specified filter index.
///
/// Gets the filter period in FPGA cycles.  Even though there are 2 different
/// filter index domains (MXP vs HDR), ignore that distinction for now since it
/// compilicates the interface.  Set status to NiFpga_Status_SoftwareFault if the
/// filter values miss-match.
///
/// @param filterIndex the filter index, 0 - 2
/// @param value       the number of cycles that the signal must not transition
/// to be counted as a transition. 
 pub fn HAL_GetFilterPeriod ( filterIndex : i32 , status : * mut i32 ) -> i64 ; } # [ repr ( C ) ] # [ derive ( Debug , Default , Copy , Clone ) ] pub struct HAL_ControlWord { pub _bitfield_1 : __BindgenBitfieldUnit < [ u8 ; 4usize ] , u32 > , pub __bindgen_align : [ u32 ; 0usize ] , } # [ test ] fn bindgen_test_layout_HAL_ControlWord ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_ControlWord > ( ) , 4usize , concat ! ( "Size of: " , stringify ! ( HAL_ControlWord ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_ControlWord > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( HAL_ControlWord ) ) ) ; } impl HAL_ControlWord { # [ inline ] pub fn enabled ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 0usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_enabled ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 0usize , 1u8 , val as u64 ) } } # [ inline ] pub fn autonomous ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 1usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_autonomous ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 1usize , 1u8 , val as u64 ) } } # [ inline ] pub fn test ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 2usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_test ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 2usize , 1u8 , val as u64 ) } } # [ inline ] pub fn eStop ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 3usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_eStop ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 3usize , 1u8 , val as u64 ) } } # [ inline ] pub fn fmsAttached ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 4usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_fmsAttached ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 4usize , 1u8 , val as u64 ) } } # [ inline ] pub fn dsAttached ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 5usize , 1u8 ) as u32 ) } } # [ inline ] pub fn set_dsAttached ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 5usize , 1u8 , val as u64 ) } } # [ inline ] pub fn control_reserved ( & self ) -> u32 { unsafe { :: std :: mem :: transmute ( self . _bitfield_1 . get ( 6usize , 26u8 ) as u32 ) } } # [ inline ] pub fn set_control_reserved ( & mut self , val : u32 ) { unsafe { let val : u32 = :: std :: mem :: transmute ( val ) ; self . _bitfield_1 . set ( 6usize , 26u8 , val as u64 ) } } # [ inline ] pub fn new_bitfield_1 ( enabled : u32 , autonomous : u32 , test : u32 , eStop : u32 , fmsAttached : u32 , dsAttached : u32 , control_reserved : u32 ) -> __BindgenBitfieldUnit < [ u8 ; 4usize ] , u32 > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [ u8 ; 4usize ] , u32 > = Default :: default ( ) ; __bindgen_bitfield_unit . set ( 0usize , 1u8 , { let enabled : u32 = unsafe { :: std :: mem :: transmute ( enabled ) } ; enabled as u64 } ) ; __bindgen_bitfield_unit . set ( 1usize , 1u8 , { let autonomous : u32 = unsafe { :: std :: mem :: transmute ( autonomous ) } ; autonomous as u64 } ) ; __bindgen_bitfield_unit . set ( 2usize , 1u8 , { let test : u32 = unsafe { :: std :: mem :: transmute ( test ) } ; test as u64 } ) ; __bindgen_bitfield_unit . set ( 3usize , 1u8 , { let eStop : u32 = unsafe { :: std :: mem :: transmute ( eStop ) } ; eStop as u64 } ) ; __bindgen_bitfield_unit . set ( 4usize , 1u8 , { let fmsAttached : u32 = unsafe { :: std :: mem :: transmute ( fmsAttached ) } ; fmsAttached as u64 } ) ; __bindgen_bitfield_unit . set ( 5usize , 1u8 , { let dsAttached : u32 = unsafe { :: std :: mem :: transmute ( dsAttached ) } ; dsAttached as u64 } ) ; __bindgen_bitfield_unit . set ( 6usize , 26u8 , { let control_reserved : u32 = unsafe { :: std :: mem :: transmute ( control_reserved ) } ; control_reserved as u64 } ) ; __bindgen_bitfield_unit } } pub mod HAL_AllianceStationID { pub type Type = i32 ; pub const HAL_AllianceStationID_kRed1 : Type = 0 ; pub const HAL_AllianceStationID_kRed2 : Type = 1 ; pub const HAL_AllianceStationID_kRed3 : Type = 2 ; pub const HAL_AllianceStationID_kBlue1 : Type = 3 ; pub const HAL_AllianceStationID_kBlue2 : Type = 4 ; pub const HAL_AllianceStationID_kBlue3 : Type = 5 ; } pub mod HAL_MatchType { pub type Type = i32 ; pub const HAL_kMatchType_none : Type = 0 ; pub const HAL_kMatchType_practice : Type = 1 ; pub const HAL_kMatchType_qualification : Type = 2 ; pub const HAL_kMatchType_elimination : Type = 3 ; } # [ repr ( C ) ] # [ derive ( Debug , Default , Copy , Clone ) ] pub struct HAL_JoystickAxes { pub count : i16 , pub axes : [ f32 ; 12usize ] , } # [ test ] fn bindgen_test_layout_HAL_JoystickAxes ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_JoystickAxes > ( ) , 52usize , concat ! ( "Size of: " , stringify ! ( HAL_JoystickAxes ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_JoystickAxes > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( HAL_JoystickAxes ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickAxes > ( ) ) ) . count as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickAxes ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickAxes > ( ) ) ) . axes as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickAxes ) , "::" , stringify ! ( axes ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Default , Copy , Clone ) ] pub struct HAL_JoystickPOVs { pub count : i16 , pub povs : [ i16 ; 12usize ] , } # [ test ] fn bindgen_test_layout_HAL_JoystickPOVs ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_JoystickPOVs > ( ) , 26usize , concat ! ( "Size of: " , stringify ! ( HAL_JoystickPOVs ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_JoystickPOVs > ( ) , 2usize , concat ! ( "Alignment of " , stringify ! ( HAL_JoystickPOVs ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickPOVs > ( ) ) ) . count as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickPOVs ) , "::" , stringify ! ( count ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickPOVs > ( ) ) ) . povs as * const _ as usize } , 2usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickPOVs ) , "::" , stringify ! ( povs ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Default , Copy , Clone ) ] pub struct HAL_JoystickButtons { pub buttons : u32 , pub count : u8 , } # [ test ] fn bindgen_test_layout_HAL_JoystickButtons ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_JoystickButtons > ( ) , 8usize , concat ! ( "Size of: " , stringify ! ( HAL_JoystickButtons ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_JoystickButtons > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( HAL_JoystickButtons ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickButtons > ( ) ) ) . buttons as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickButtons ) , "::" , stringify ! ( buttons ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickButtons > ( ) ) ) . count as * const _ as usize } , 4usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickButtons ) , "::" , stringify ! ( count ) ) ) ; } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct HAL_JoystickDescriptor { pub isXbox : u8 , pub type_ : u8 , pub name : [ :: std :: os :: raw :: c_char ; 256usize ] , pub axisCount : u8 , pub axisTypes : [ u8 ; 12usize ] , pub buttonCount : u8 , pub povCount : u8 , } # [ test ] fn bindgen_test_layout_HAL_JoystickDescriptor ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_JoystickDescriptor > ( ) , 273usize , concat ! ( "Size of: " , stringify ! ( HAL_JoystickDescriptor ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_JoystickDescriptor > ( ) , 1usize , concat ! ( "Alignment of " , stringify ! ( HAL_JoystickDescriptor ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . isXbox as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( isXbox ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . type_ as * const _ as usize } , 1usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( type_ ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . name as * const _ as usize } , 2usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( name ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . axisCount as * const _ as usize } , 258usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( axisCount ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . axisTypes as * const _ as usize } , 259usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( axisTypes ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . buttonCount as * const _ as usize } , 271usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( buttonCount ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_JoystickDescriptor > ( ) ) ) . povCount as * const _ as usize } , 272usize , concat ! ( "Offset of field: " , stringify ! ( HAL_JoystickDescriptor ) , "::" , stringify ! ( povCount ) ) ) ; } impl Default for HAL_JoystickDescriptor { fn default ( ) -> Self { unsafe { :: std :: mem :: zeroed ( ) } } } # [ repr ( C ) ] # [ derive ( Copy , Clone ) ] pub struct HAL_MatchInfo { pub eventName : [ :: std :: os :: raw :: c_char ; 64usize ] , pub matchType : HAL_MatchType::Type , pub matchNumber : u16 , pub replayNumber : u8 , pub gameSpecificMessage : [ u8 ; 64usize ] , pub gameSpecificMessageSize : u16 , } # [ test ] fn bindgen_test_layout_HAL_MatchInfo ( ) { assert_eq ! ( :: std :: mem :: size_of :: < HAL_MatchInfo > ( ) , 140usize , concat ! ( "Size of: " , stringify ! ( HAL_MatchInfo ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < HAL_MatchInfo > ( ) , 4usize , concat ! ( "Alignment of " , stringify ! ( HAL_MatchInfo ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_MatchInfo > ( ) ) ) . eventName as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( HAL_MatchInfo ) , "::" , stringify ! ( eventName ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_MatchInfo > ( ) ) ) . matchType as * const _ as usize } , 64usize , concat ! ( "Offset of field: " , stringify ! ( HAL_MatchInfo ) , "::" , stringify ! ( matchType ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_MatchInfo > ( ) ) ) . matchNumber as * const _ as usize } , 68usize , concat ! ( "Offset of field: " , stringify ! ( HAL_MatchInfo ) , "::" , stringify ! ( matchNumber ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_MatchInfo > ( ) ) ) . replayNumber as * const _ as usize } , 70usize , concat ! ( "Offset of field: " , stringify ! ( HAL_MatchInfo ) , "::" , stringify ! ( replayNumber ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_MatchInfo > ( ) ) ) . gameSpecificMessage as * const _ as usize } , 71usize , concat ! ( "Offset of field: " , stringify ! ( HAL_MatchInfo ) , "::" , stringify ! ( gameSpecificMessage ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < HAL_MatchInfo > ( ) ) ) . gameSpecificMessageSize as * const _ as usize } , 136usize , concat ! ( "Offset of field: " , stringify ! ( HAL_MatchInfo ) , "::" , stringify ! ( gameSpecificMessageSize ) ) ) ; } impl Default for HAL_MatchInfo { fn default ( ) -> Self { unsafe { :: std :: mem :: zeroed ( ) } } } extern "C" { 
 /// Sends an error to the driver station.
///
/// @param isError   true for error, false for warning
/// @param errorCode the error code
/// @param isLVCode  true for a LV error code, false for a standard error code
/// @param details   the details of the error
/// @param location  the file location of the errror
/// @param callstack the callstack of the error
/// @param printMsg  true to print the error message to stdout as well as to the
/// DS 
 pub fn HAL_SendError ( isError : HAL_Bool , errorCode : i32 , isLVCode : HAL_Bool , details : * const :: std :: os :: raw :: c_char , location : * const :: std :: os :: raw :: c_char , callStack : * const :: std :: os :: raw :: c_char , printMsg : HAL_Bool ) -> i32 ; } extern "C" { 
 /// Gets the current control word of the driver station.
///
/// The control work contains the robot state.
///
/// @param controlWord the control word (out)
/// @return            the error code, or 0 for success 
 pub fn HAL_GetControlWord ( controlWord : * mut HAL_ControlWord ) -> i32 ; } extern "C" { 
 /// Gets the current alliance station ID.
///
/// @param status the error code, or 0 for success
/// @return       the alliance station ID 
 pub fn HAL_GetAllianceStation ( status : * mut i32 ) -> HAL_AllianceStationID::Type ; } extern "C" { 
 /// Gets the axes of a specific joystick.
///
/// @param joystickNum the joystick number
/// @param axes        the axes values (output)
/// @return            the error code, or 0 for success 
 pub fn HAL_GetJoystickAxes ( joystickNum : i32 , axes : * mut HAL_JoystickAxes ) -> i32 ; } extern "C" { 
 /// Gets the POVs of a specific joystick.
///
/// @param joystickNum the joystick number
/// @param povs        the POV values (output)
/// @return            the error code, or 0 for success 
 pub fn HAL_GetJoystickPOVs ( joystickNum : i32 , povs : * mut HAL_JoystickPOVs ) -> i32 ; } extern "C" { 
 /// Gets the buttons of a specific joystick.
///
/// @param joystickNum the joystick number
/// @param buttons     the button values (output)
/// @return            the error code, or 0 for success 
 pub fn HAL_GetJoystickButtons ( joystickNum : i32 , buttons : * mut HAL_JoystickButtons ) -> i32 ; } extern "C" { 
 /// Retrieves the Joystick Descriptor for particular slot.
///
/// @param desc [out] descriptor (data transfer object) to fill in.  desc is
/// filled in regardless of success. In other words, if descriptor is not
/// available, desc is filled in with default values matching the init-values in
/// Java and C++ Driverstation for when caller requests a too-large joystick
/// index.
///
/// @return error code reported from Network Comm back-end.  Zero is good,
/// nonzero is bad. 
 pub fn HAL_GetJoystickDescriptor ( joystickNum : i32 , desc : * mut HAL_JoystickDescriptor ) -> i32 ; } extern "C" { 
 /// Gets is a specific joystick is considered to be an XBox controller.
///
/// @param joystickNum the joystick number
/// @return            true if xbox, false otherwise 
 pub fn HAL_GetJoystickIsXbox ( joystickNum : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the type of joystick connected.
///
/// This is device specific, and different depending on what system input type
/// the joystick uses.
///
/// @param joystickNum the joystick number
/// @return            the enumerated joystick type 
 pub fn HAL_GetJoystickType ( joystickNum : i32 ) -> i32 ; } extern "C" { 
 /// Gets the name of a joystick.
///
/// The returned array must be freed with HAL_FreeJoystickName.
///
/// Will be null terminated.
///
/// @param joystickNum the joystick number
/// @return            the joystick name 
 pub fn HAL_GetJoystickName ( joystickNum : i32 ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Frees a joystick name received with HAL_GetJoystickName
///
/// @param name the name storage 
 pub fn HAL_FreeJoystickName ( name : * mut :: std :: os :: raw :: c_char ) ; } extern "C" { 
 /// Gets the type of a specific joystick axis.
///
/// This is device specific, and different depending on what system input type
/// the joystick uses.
///
/// @param joystickNum the joystick number
/// @param axis        the axis number
/// @return            the enumerated axis type 
 pub fn HAL_GetJoystickAxisType ( joystickNum : i32 , axis : i32 ) -> i32 ; } extern "C" { 
 /// Set joystick outputs.
///
/// @param joystickNum the joystick numer
/// @param outputs     bitmask of outputs, 1 for on 0 for off
/// @param leftRumble  the left rumble value (0-FFFF)
/// @param rightRumble the right rumble value (0-FFFF)
/// @return            the error code, or 0 for success 
 pub fn HAL_SetJoystickOutputs ( joystickNum : i32 , outputs : i64 , leftRumble : i32 , rightRumble : i32 ) -> i32 ; } extern "C" { 
 /// Returns the approximate match time.
///
/// The FMS does not send an official match time to the robots, but does send
/// an approximate match time. The value will count down the time remaining in
/// the current period (auto or teleop).
///
/// Warning: This is not an official time (so it cannot be used to dispute ref
/// calls or guarantee that a function will trigger before the match ends).
///
/// The Practice Match function of the DS approximates the behaviour seen on
/// the field.
///
/// @param status the error code, or 0 for success
/// @return time remaining in current match period (auto or teleop) 
 pub fn HAL_GetMatchTime ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets info about a specific match.
///
/// @param info the match info (output)
/// @return     the error code, or 0 for success 
 pub fn HAL_GetMatchInfo ( info : * mut HAL_MatchInfo ) -> i32 ; } extern "C" { 
 /// Releases the DS Mutex to allow proper shutdown of any threads that are
/// waiting on it. 
 pub fn HAL_ReleaseDSMutex ( ) ; } extern "C" { 
 /// Has a new control packet from the driver station arrived since the last
/// time this function was called?
///
/// @return true if the control data has been updated since the last call 
 pub fn HAL_IsNewControlData ( ) -> HAL_Bool ; } extern "C" { 
 /// Waits for the newest DS packet to arrive. Note that this is a blocking call. 
 pub fn HAL_WaitForDSData ( ) ; } extern "C" { 
 /// Waits for the newest DS packet to arrive. If timeout is <= 0, this will wait
/// forever. Otherwise, it will wait until either a new packet, or the timeout
/// time has passed.
///
/// @param timeout timeout in seconds
/// @return        true for new data, false for timeout 
 pub fn HAL_WaitForDSDataTimeout ( timeout : f64 ) -> HAL_Bool ; } extern "C" { 
 /// Initializes the driver station communication. This will properly
/// handle multiple calls. However note that this CANNOT be called from a library
/// that interfaces with LabVIEW. 
 pub fn HAL_InitializeDriverStation ( ) ; } extern "C" { 
 /// Sets the program starting flag in the DS.
///
/// This is what changes the DS to showing robot code ready. 
 pub fn HAL_ObserveUserProgramStarting ( ) ; } extern "C" { 
 /// Sets the disabled flag in the DS.
///
/// This is used for the DS to ensure the robot is properly responding to its
/// state request. Ensure this get called about every 50ms, or the robot will be
/// disabled by the DS. 
 pub fn HAL_ObserveUserProgramDisabled ( ) ; } extern "C" { 
 /// Sets the autonomous enabled flag in the DS.
///
/// This is used for the DS to ensure the robot is properly responding to its
/// state request. Ensure this get called about every 50ms, or the robot will be
/// disabled by the DS. 
 pub fn HAL_ObserveUserProgramAutonomous ( ) ; } extern "C" { 
 /// Sets the teleoperated enabled flag in the DS.
///
/// This is used for the DS to ensure the robot is properly responding to its
/// state request. Ensure this get called about every 50ms, or the robot will be
/// disabled by the DS. 
 pub fn HAL_ObserveUserProgramTeleop ( ) ; } extern "C" { 
 /// Sets the test mode flag in the DS.
///
/// This is used for the DS to ensure the robot is properly responding to its
/// state request. Ensure this get called about every 50ms, or the robot will be
/// disabled by the DS. 
 pub fn HAL_ObserveUserProgramTest ( ) ; } pub mod HAL_I2CPort { 
 /// @defgroup hal_i2c I2C Functions
/// @ingroup hal_capi
/// @{ 
 pub type Type = i32 ; pub const HAL_I2C_kInvalid : Type = -1 ; pub const HAL_I2C_kOnboard : Type = 0 ; pub const HAL_I2C_kMXP : Type = 1 ; } extern "C" { 
 /// Initializes the I2C port.
///
/// Opens the port if necessary and saves the handle.
/// If opening the MXP port, also sets up the channel functions appropriately.
///
/// @param port The port to open, 0 for the on-board, 1 for the MXP. 
 pub fn HAL_InitializeI2C ( port : HAL_I2CPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Generic I2C read/write transaction.
///
/// This is a lower-level interface to the I2C hardware giving you more control
/// over each transaction.
///
/// @param port The I2C port, 0 for the on-board, 1 for the MXP.
/// @param dataToSend Buffer of data to send as part of the transaction.
/// @param sendSize Number of bytes to send as part of the transaction.
/// @param dataReceived Buffer to read data into.
/// @param receiveSize Number of bytes to read from the device.
/// @return >= 0 on success or -1 on transfer abort. 
 pub fn HAL_TransactionI2C ( port : HAL_I2CPort::Type , deviceAddress : i32 , dataToSend : * const u8 , sendSize : i32 , dataReceived : * mut u8 , receiveSize : i32 ) -> i32 ; } extern "C" { 
 /// Executes a write transaction with the device.
///
/// Writes a single byte to a register on a device and wait until the
///   transaction is complete.
///
/// @param port The I2C port, 0 for the on-board, 1 for the MXP.
/// @param registerAddress The address of the register on the device to be
/// written.
/// @param data The byte to write to the register on the device.
/// @return >= 0 on success or -1 on transfer abort. 
 pub fn HAL_WriteI2C ( port : HAL_I2CPort::Type , deviceAddress : i32 , dataToSend : * const u8 , sendSize : i32 ) -> i32 ; } extern "C" { 
 /// Executes a read transaction with the device.
///
/// Reads bytes from a device.
/// Most I2C devices will auto-increment the register pointer internally allowing
///   you to read consecutive registers on a device in a single transaction.
///
/// @param port The I2C port, 0 for the on-board, 1 for the MXP.
/// @param registerAddress The register to read first in the transaction.
/// @param count The number of bytes to read in the transaction.
/// @param buffer A pointer to the array of bytes to store the data read from the
/// device.
/// @return >= 0 on success or -1 on transfer abort. 
 pub fn HAL_ReadI2C ( port : HAL_I2CPort::Type , deviceAddress : i32 , buffer : * mut u8 , count : i32 ) -> i32 ; } extern "C" { 
 /// Closes an I2C port
///
/// @param port The I2C port, 0 for the on-board, 1 for the MXP. 
 pub fn HAL_CloseI2C ( port : HAL_I2CPort::Type ) ; } pub type HAL_InterruptHandlerFunction = :: std :: option :: Option < unsafe extern "C" fn ( interruptAssertedMask : u32 , param : * mut :: std :: os :: raw :: c_void ) > ; extern "C" { 
 /// Initializes an interrupt.
///
/// @param watcher true for synchronous interrupts, false for asynchronous
/// @return        the created interrupt handle 
 pub fn HAL_InitializeInterrupts ( watcher : HAL_Bool , status : * mut i32 ) -> HAL_InterruptHandle ; } extern "C" { 
 /// Frees an interrupt.
///
/// @param interruptHandle the interrupt handle
/// @return                the param passed to the interrupt, or nullptr if one
/// wasn't passed. 
 pub fn HAL_CleanInterrupts ( interruptHandle : HAL_InterruptHandle , status : * mut i32 ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { 
 /// In synchronous mode, waits for the defined interrupt to occur.
///
/// @param interruptHandle the interrupt handle
/// @param timeout        timeout in seconds
/// @param ignorePrevious if true, ignore interrupts that happened before
/// waitForInterrupt was called
/// @return               the mask of interrupts that fired 
 pub fn HAL_WaitForInterrupt ( interruptHandle : HAL_InterruptHandle , timeout : f64 , ignorePrevious : HAL_Bool , status : * mut i32 ) -> i64 ; } extern "C" { 
 /// Enables interrupts to occur on this input.
///
/// Interrupts are disabled when the RequestInterrupt call is made. This gives
/// time to do the setup of the other options before starting to field
/// interrupts.
///
/// @param interruptHandle the interrupt handle 
 pub fn HAL_EnableInterrupts ( interruptHandle : HAL_InterruptHandle , status : * mut i32 ) ; } extern "C" { 
 /// Disables interrupts without without deallocating structures.
///
/// @param interruptHandle the interrupt handle 
 pub fn HAL_DisableInterrupts ( interruptHandle : HAL_InterruptHandle , status : * mut i32 ) ; } extern "C" { 
 /// Returns the timestamp for the rising interrupt that occurred most recently.
///
/// This is in the same time domain as HAL_GetFPGATime().
///
/// @param interruptHandle the interrupt handle
/// @return                timestamp in seconds since FPGA Initialization 
 pub fn HAL_ReadInterruptRisingTimestamp ( interruptHandle : HAL_InterruptHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Returns the timestamp for the falling interrupt that occurred most recently.
///
/// This is in the same time domain as HAL_GetFPGATime().
///
/// @param interruptHandle the interrupt handle
/// @return                timestamp in seconds since FPGA Initialization 
 pub fn HAL_ReadInterruptFallingTimestamp ( interruptHandle : HAL_InterruptHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Requests interrupts on a specific digital source.
///
/// @param interruptHandle     the interrupt handle
/// @param digitalSourceHandle the digital source handle (either a
/// HAL_AnalogTriggerHandle of a HAL_DigitalHandle)
/// @param analogTriggerType   the trigger type if the source is an AnalogTrigger 
 pub fn HAL_RequestInterrupts ( interruptHandle : HAL_InterruptHandle , digitalSourceHandle : HAL_Handle , analogTriggerType : HAL_AnalogTriggerType::Type , status : * mut i32 ) ; } extern "C" { 
 /// Attaches an asynchronous interrupt handler to the interrupt.
///
/// This interrupt gets called directly on the FPGA interrupt thread, so will
/// block other interrupts while running.
///
/// @param interruptHandle the interrupt handle
/// @param handler         the handler function for the interrupt to call
/// @param param           a parameter to be passed to the handler 
 pub fn HAL_AttachInterruptHandler ( interruptHandle : HAL_InterruptHandle , handler : HAL_InterruptHandlerFunction , param : * mut :: std :: os :: raw :: c_void , status : * mut i32 ) ; } extern "C" { 
 /// Attaches an asynchronous interrupt handler to the interrupt.
///
/// This interrupt gets called on a thread specific to the interrupt, so will not
/// block other interrupts.
///
/// @param interruptHandle the interrupt handle
/// @param handler         the handler function for the interrupt to call
/// @param param           a parameter to be passed to the handler 
 pub fn HAL_AttachInterruptHandlerThreaded ( interruptHandle : HAL_InterruptHandle , handler : HAL_InterruptHandlerFunction , param : * mut :: std :: os :: raw :: c_void , status : * mut i32 ) ; } extern "C" { 
 /// Sets the edges to trigger the interrupt on.
///
/// Note that both edges triggered is a valid configuration.
///
/// @param interruptHandle the interrupt handle
/// @param risingEdge      true for triggering on rising edge
/// @param fallingEdge     true for triggering on falling edge 
 pub fn HAL_SetInterruptUpSourceEdge ( interruptHandle : HAL_InterruptHandle , risingEdge : HAL_Bool , fallingEdge : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Initializes a notifier.
///
/// A notifier is an FPGA controller timer that triggers at requested intervals
/// based on the FPGA time. This can be used to make precise control loops.
///
/// @return the created notifier 
 pub fn HAL_InitializeNotifier ( status : * mut i32 ) -> HAL_NotifierHandle ; } extern "C" { 
 /// Stops a notifier from running.
///
/// This will cause any call into HAL_WaitForNotifierAlarm to return.
///
/// @param notifierHandle the notifier handle 
 pub fn HAL_StopNotifier ( notifierHandle : HAL_NotifierHandle , status : * mut i32 ) ; } extern "C" { 
 /// Cleans a notifier.
///
/// Note this also stops a notifier if it is already running.
///
/// @param notifierHandle the notifier handle 
 pub fn HAL_CleanNotifier ( notifierHandle : HAL_NotifierHandle , status : * mut i32 ) ; } extern "C" { 
 /// Updates the trigger time for a notifier.
///
/// Note that this time is an absolute time relative to HAL_GetFPGATime()
///
/// @param notifierHandle the notifier handle
/// @param triggerTime    the updated trigger time 
 pub fn HAL_UpdateNotifierAlarm ( notifierHandle : HAL_NotifierHandle , triggerTime : u64 , status : * mut i32 ) ; } extern "C" { 
 /// Cancels the next notifier alarm.
///
/// This does not cause HAL_WaitForNotifierAlarm to return.
///
/// @param notifierHandle the notifier handle 
 pub fn HAL_CancelNotifierAlarm ( notifierHandle : HAL_NotifierHandle , status : * mut i32 ) ; } extern "C" { 
 /// Waits for the next alarm for the specific notifier.
///
/// This is a blocking call until either the time elapses or HAL_StopNotifier
/// gets called.
///
/// @param notifierHandle the notifier handle
/// @return               the FPGA time the notifier returned 
 pub fn HAL_WaitForNotifierAlarm ( notifierHandle : HAL_NotifierHandle , status : * mut i32 ) -> u64 ; } extern "C" { 
 /// Initializes a Power Distribution Panel.
///
/// @param  module the module number to initialize
/// @return the created PDP 
 pub fn HAL_InitializePDP ( module : i32 , status : * mut i32 ) -> HAL_PDPHandle ; } extern "C" { 
 /// Cleans a PDP module.
///
/// @param handle the module handle 
 pub fn HAL_CleanPDP ( handle : HAL_PDPHandle ) ; } extern "C" { 
 /// Checks if a PDP channel is valid.
///
/// @param channel the channel to check
/// @return        true if the channel is valid, otherwise false 
 pub fn HAL_CheckPDPChannel ( channel : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Checks if a PDP module is valid.
///
/// @param channel the module to check
/// @return        true if the module is valid, otherwise false 
 pub fn HAL_CheckPDPModule ( module : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the temperature of the PDP.
///
/// @param handle the module handle
/// @return       the module temperature (celsius) 
 pub fn HAL_GetPDPTemperature ( handle : HAL_PDPHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the PDP input voltage.
///
/// @param handle the module handle
/// @return       the input voltage (volts) 
 pub fn HAL_GetPDPVoltage ( handle : HAL_PDPHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the current of a specific PDP channel.
///
/// @param module  the module
/// @param channel the channel
/// @return        the channel current (amps) 
 pub fn HAL_GetPDPChannelCurrent ( handle : HAL_PDPHandle , channel : i32 , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the total current of the PDP.
///
/// @param handle the module handle
/// @return       the total current (amps) 
 pub fn HAL_GetPDPTotalCurrent ( handle : HAL_PDPHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the total power of the PDP.
///
/// @param handle the module handle
/// @return       the total power (watts) 
 pub fn HAL_GetPDPTotalPower ( handle : HAL_PDPHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the total energy of the PDP.
///
/// @param handle the module handle
/// @return       the total energy (joules) 
 pub fn HAL_GetPDPTotalEnergy ( handle : HAL_PDPHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Resets the PDP accumulated energy.
///
/// @param handle the module handle 
 pub fn HAL_ResetPDPTotalEnergy ( handle : HAL_PDPHandle , status : * mut i32 ) ; } extern "C" { 
 /// Clears any PDP sticky faults.
///
/// @param handle the module handle 
 pub fn HAL_ClearPDPStickyFaults ( handle : HAL_PDPHandle , status : * mut i32 ) ; } extern "C" { 
 /// Initializes a PWM port.
///
/// @param portHandle the port to initialize
/// @return           the created pwm handle 
 pub fn HAL_InitializePWMPort ( portHandle : HAL_PortHandle , status : * mut i32 ) -> HAL_DigitalHandle ; } extern "C" { 
 /// Frees a PWM port.
///
/// @param pwmPortHandle the pwm handle 
 pub fn HAL_FreePWMPort ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) ; } extern "C" { 
 /// Checks if a pwm channel is valid.
///
/// @param channel the channel to check
/// @return        true if the channel is valid, otherwise false 
 pub fn HAL_CheckPWMChannel ( channel : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Sets the configuration settings for the PWM channel.
///
/// All values are in milliseconds.
///
/// @param pwmPortHandle  the PWM handle
/// @param maxPwm         the maximum PWM value
/// @param deadbandMaxPwm the high range of the center deadband
/// @param centerPwm      the center PWM value
/// @param deadbandMinPwm the low range of the center deadband
/// @param minPwm         the minimum PWM value 
 pub fn HAL_SetPWMConfig ( pwmPortHandle : HAL_DigitalHandle , maxPwm : f64 , deadbandMaxPwm : f64 , centerPwm : f64 , deadbandMinPwm : f64 , minPwm : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the raw configuration settings for the PWM channel.
///
/// We recommend using HAL_SetPWMConfig() instead, as those values are properly
/// scaled. Usually used for values grabbed by HAL_GetPWMConfigRaw().
///
/// Values are in raw FPGA units.
///
/// @param pwmPortHandle  the PWM handle
/// @param maxPwm         the maximum PWM value
/// @param deadbandMaxPwm the high range of the center deadband
/// @param centerPwm      the center PWM value
/// @param deadbandMinPwm the low range of the center deadband
/// @param minPwm         the minimum PWM value 
 pub fn HAL_SetPWMConfigRaw ( pwmPortHandle : HAL_DigitalHandle , maxPwm : i32 , deadbandMaxPwm : i32 , centerPwm : i32 , deadbandMinPwm : i32 , minPwm : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the raw pwm configuration settings for the PWM channel.
///
/// Values are in raw FPGA units. These units have the potential to change for
/// any FPGA release.
///
/// @param pwmPortHandle  the PWM handle
/// @param maxPwm         the maximum PWM value
/// @param deadbandMaxPwm the high range of the center deadband
/// @param centerPwm      the center PWM value
/// @param deadbandMinPwm the low range of the center deadband
/// @param minPwm         the minimum PWM value 
 pub fn HAL_GetPWMConfigRaw ( pwmPortHandle : HAL_DigitalHandle , maxPwm : * mut i32 , deadbandMaxPwm : * mut i32 , centerPwm : * mut i32 , deadbandMinPwm : * mut i32 , minPwm : * mut i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets if the FPGA should output the center value if the input value is within
/// the deadband.
///
/// @param pwmPortHandle     the PWM handle
/// @param eliminateDeadband true to eliminate deadband, otherwise false 
 pub fn HAL_SetPWMEliminateDeadband ( pwmPortHandle : HAL_DigitalHandle , eliminateDeadband : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Gets the current eliminate deadband value.
///
/// @param pwmPortHandle the PWM handle
/// @return              true if set, otherwise false 
 pub fn HAL_GetPWMEliminateDeadband ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Sets a PWM channel to the desired value.
///
/// The values are in raw FPGA units, and have the potential to change with any
/// FPGA release.
///
/// @param pwmPortHandle the PWM handle
/// @param value         the PWM value to set 
 pub fn HAL_SetPWMRaw ( pwmPortHandle : HAL_DigitalHandle , value : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets a PWM channel to the desired scaled value.
///
/// The values range from -1 to 1 and the period is controlled by the PWM Period
/// and MinHigh registers.
///
/// @param pwmPortHandle the PWM handle
/// @param value         the scaled PWM value to set 
 pub fn HAL_SetPWMSpeed ( pwmPortHandle : HAL_DigitalHandle , speed : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Sets a PWM channel to the desired position value.
///
/// The values range from 0 to 1 and the period is controlled by the PWM Period
/// and MinHigh registers.
///
/// @param pwmPortHandle the PWM handle
/// @param value         the positional PWM value to set 
 pub fn HAL_SetPWMPosition ( pwmPortHandle : HAL_DigitalHandle , position : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Sets a PWM channel to be disabled.
///
/// The channel is disabled until the next time it is set. Note this is different
/// from just setting a 0 speed, as this will actively stop all signalling on the
/// channel.
///
/// @param pwmPortHandle the PWM handle. 
 pub fn HAL_SetPWMDisabled ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) ; } extern "C" { 
 /// Gets a value from a PWM channel.
///
/// The values are in raw FPGA units, and have the potential to change with any
/// FPGA release.
///
/// @param pwmPortHandle the PWM handle
/// @return              the current raw PWM value 
 pub fn HAL_GetPWMRaw ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets a scaled value from a PWM channel.
///
/// The values range from -1 to 1.
///
/// @param pwmPortHandle the PWM handle
/// @return              the current speed PWM value 
 pub fn HAL_GetPWMSpeed ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets a position value from a PWM channel.
///
/// The values range from 0 to 1.
///
/// @param pwmPortHandle the PWM handle
/// @return              the current positional PWM value 
 pub fn HAL_GetPWMPosition ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Forces a PWM signal to go to 0 temporarily.
///
/// @param pwmPortHandle the PWM handle. 
 pub fn HAL_LatchPWMZero ( pwmPortHandle : HAL_DigitalHandle , status : * mut i32 ) ; } extern "C" { 
 /// Sets how how often the PWM signal is squelched, thus scaling the period.
///
/// @param pwmPortHandle the PWM handle.
/// @param squelchMask   the 2-bit mask of outputs to squelch 
 pub fn HAL_SetPWMPeriodScale ( pwmPortHandle : HAL_DigitalHandle , squelchMask : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the loop timing of the PWM system.
///
/// @return the loop time 
 pub fn HAL_GetPWMLoopTiming ( status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the pwm starting cycle time.
///
/// This time is relative to the FPGA time.
///
/// @return the pwm cycle start time 
 pub fn HAL_GetPWMCycleStartTime ( status : * mut i32 ) -> u64 ; } extern "C" { 
 /// Gets the number of analog accumulators in the current system.
///
/// @return the number of analog accumulators 
 pub fn HAL_GetNumAccumulators ( ) -> i32 ; } extern "C" { 
 /// Gets the number of analog triggers in the current system.
///
/// @return the number of analog triggers 
 pub fn HAL_GetNumAnalogTriggers ( ) -> i32 ; } extern "C" { 
 /// Gets the number of analog inputs in the current system.
///
/// @return the number of analog inputs 
 pub fn HAL_GetNumAnalogInputs ( ) -> i32 ; } extern "C" { 
 /// Gets the number of analog outputs in the current system.
///
/// @return the number of analog outputs 
 pub fn HAL_GetNumAnalogOutputs ( ) -> i32 ; } extern "C" { 
 /// Gets the number of analog counters in the current system.
///
/// @return the number of counters 
 pub fn HAL_GetNumCounters ( ) -> i32 ; } extern "C" { 
 /// Gets the number of digital headers in the current system.
///
/// @return the number of digital headers 
 pub fn HAL_GetNumDigitalHeaders ( ) -> i32 ; } extern "C" { 
 /// Gets the number of PWM headers in the current system.
///
/// @return the number of PWM headers 
 pub fn HAL_GetNumPWMHeaders ( ) -> i32 ; } extern "C" { 
 /// Gets the number of digital channels in the current system.
///
/// @return the number of digital channels 
 pub fn HAL_GetNumDigitalChannels ( ) -> i32 ; } extern "C" { 
 /// Gets the number of PWM channels in the current system.
///
/// @return the number of PWM channels 
 pub fn HAL_GetNumPWMChannels ( ) -> i32 ; } extern "C" { 
 /// Gets the number of digital IO PWM outputs in the current system.
///
/// @return the number of digital IO PWM outputs 
 pub fn HAL_GetNumDigitalPWMOutputs ( ) -> i32 ; } extern "C" { 
 /// Gets the number of quadrature encoders in the current system.
///
/// @return the number of quadrature encoders 
 pub fn HAL_GetNumEncoders ( ) -> i32 ; } extern "C" { 
 /// Gets the number of interrupts in the current system.
///
/// @return the number of interrupts 
 pub fn HAL_GetNumInterrupts ( ) -> i32 ; } extern "C" { 
 /// Gets the number of relay channels in the current system.
///
/// @return the number of relay channels 
 pub fn HAL_GetNumRelayChannels ( ) -> i32 ; } extern "C" { 
 /// Gets the number of relay headers in the current system.
///
/// @return the number of relay headers 
 pub fn HAL_GetNumRelayHeaders ( ) -> i32 ; } extern "C" { 
 /// Gets the number of PCM modules in the current system.
///
/// @return the number of PCM modules 
 pub fn HAL_GetNumPCMModules ( ) -> i32 ; } extern "C" { 
 /// Gets the number of solenoid channels in the current system.
///
/// @return the number of solenoid channels 
 pub fn HAL_GetNumSolenoidChannels ( ) -> i32 ; } extern "C" { 
 /// Gets the number of PDP modules in the current system.
///
/// @return the number of PDP modules 
 pub fn HAL_GetNumPDPModules ( ) -> i32 ; } extern "C" { 
 /// Gets the number of PDP channels in the current system.
///
/// @return the number of PDP channels 
 pub fn HAL_GetNumPDPChannels ( ) -> i32 ; } extern "C" { 
 /// Gets the roboRIO input voltage.
///
/// @return the input voltage (volts) 
 pub fn HAL_GetVinVoltage ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the roboRIO input current.
///
/// @return the input current (amps) 
 pub fn HAL_GetVinCurrent ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the 6V rail voltage.
///
/// @return the 6V rail voltage (volts) 
 pub fn HAL_GetUserVoltage6V ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the 6V rail current.
///
/// @return the 6V rail current (amps) 
 pub fn HAL_GetUserCurrent6V ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the active state of the 6V rail.
///
/// @return true if the rail is active, otherwise false 
 pub fn HAL_GetUserActive6V ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the fault count for the 6V rail.
///
/// @return the number of 6V fault counts 
 pub fn HAL_GetUserCurrentFaults6V ( status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the 5V rail voltage.
///
/// @return the 5V rail voltage (volts) 
 pub fn HAL_GetUserVoltage5V ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the 5V rail current.
///
/// @return the 5V rail current (amps) 
 pub fn HAL_GetUserCurrent5V ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the active state of the 5V rail.
///
/// @return true if the rail is active, otherwise false 
 pub fn HAL_GetUserActive5V ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the fault count for the 5V rail.
///
/// @return the number of 5V fault counts 
 pub fn HAL_GetUserCurrentFaults5V ( status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the 3V3 rail voltage.
///
/// @return the 3V3 rail voltage (volts) 
 pub fn HAL_GetUserVoltage3V3 ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the 3V3 rail current.
///
/// @return the 3V3 rail current (amps) 
 pub fn HAL_GetUserCurrent3V3 ( status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the active state of the 3V3 rail.
///
/// @return true if the rail is active, otherwise false 
 pub fn HAL_GetUserActive3V3 ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the fault count for the 3V3 rail.
///
/// @return the number of 3V3 fault counts 
 pub fn HAL_GetUserCurrentFaults3V3 ( status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Initializes a relay.
///
/// Note this call will only initialize either the forward or reverse port of the
/// relay. If you need both, you will need to initialize 2 relays.
///
/// @param portHandle the port handle to initialize
/// @param fwd        true for the forward port, false for the reverse port
/// @return           the created relay handle 
 pub fn HAL_InitializeRelayPort ( portHandle : HAL_PortHandle , fwd : HAL_Bool , status : * mut i32 ) -> HAL_RelayHandle ; } extern "C" { 
 /// Frees a relay port.
///
/// @param relayPortHandle the relay handle 
 pub fn HAL_FreeRelayPort ( relayPortHandle : HAL_RelayHandle ) ; } extern "C" { 
 /// Checks if a relay channel is valid.
///
/// @param channel the channel to check
/// @return        true if the channel is valid, otherwise false 
 pub fn HAL_CheckRelayChannel ( channel : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Sets the state of a relay output.
///
/// @param relayPortHandle the relay handle
/// @param on              true for on, false for off 
 pub fn HAL_SetRelay ( relayPortHandle : HAL_RelayHandle , on : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Gets the current state of the relay channel.
///
/// @param relayPortHandle the relay handle
/// @return                true for on, false for off 
 pub fn HAL_GetRelay ( relayPortHandle : HAL_RelayHandle , status : * mut i32 ) -> HAL_Bool ; } pub mod HAL_SPIPort { 
 /// @defgroup hal_spi SPI Functions
/// @ingroup hal_capi
/// @{ 
 pub type Type = i32 ; pub const HAL_SPI_kInvalid : Type = -1 ; pub const HAL_SPI_kOnboardCS0 : Type = 0 ; pub const HAL_SPI_kOnboardCS1 : Type = 1 ; pub const HAL_SPI_kOnboardCS2 : Type = 2 ; pub const HAL_SPI_kOnboardCS3 : Type = 3 ; pub const HAL_SPI_kMXP : Type = 4 ; } extern "C" { 
 /// Initializes the SPI port. Opens the port if necessary and saves the handle.
///
/// If opening the MXP port, also sets up the channel functions appropriately.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS3, 4 for MXP 
 pub fn HAL_InitializeSPI ( port : HAL_SPIPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Performs an SPI send/receive transaction.
///
/// This is a lower-level interface to the spi hardware giving you more control
/// over each transaction.
///
/// @param port         The number of the port to use. 0-3 for Onboard CS0-CS2, 4
/// for MXP
/// @param dataToSend   Buffer of data to send as part of the transaction.
/// @param dataReceived Buffer to read data into.
/// @param size         Number of bytes to transfer. [0..7]
/// @return             Number of bytes transferred, -1 for error 
 pub fn HAL_TransactionSPI ( port : HAL_SPIPort::Type , dataToSend : * const u8 , dataReceived : * mut u8 , size : i32 ) -> i32 ; } extern "C" { 
 /// Executes a write transaction with the device.
///
/// Writes to a device and wait until the transaction is complete.
///
/// @param port      The number of the port to use. 0-3 for Onboard CS0-CS2, 4
/// for MXP
/// @param datToSend The data to write to the register on the device.
/// @param sendSize  The number of bytes to be written
/// @return          The number of bytes written. -1 for an error 
 pub fn HAL_WriteSPI ( port : HAL_SPIPort::Type , dataToSend : * const u8 , sendSize : i32 ) -> i32 ; } extern "C" { 
 /// Executes a read from the device.
///
/// This method does not write any data out to the device.
///
/// Most spi devices will require a register address to be written before they
/// begin returning data.
///
/// @param port   The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP
/// @param buffer A pointer to the array of bytes to store the data read from the
/// device.
/// @param count  The number of bytes to read in the transaction. [1..7]
/// @return       Number of bytes read. -1 for error. 
 pub fn HAL_ReadSPI ( port : HAL_SPIPort::Type , buffer : * mut u8 , count : i32 ) -> i32 ; } extern "C" { 
 /// Closes the SPI port.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for MXP 
 pub fn HAL_CloseSPI ( port : HAL_SPIPort::Type ) ; } extern "C" { 
 /// Sets the clock speed for the SPI bus.
///
/// @param port  The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP
/// @param speed The speed in Hz (0-1MHz) 
 pub fn HAL_SetSPISpeed ( port : HAL_SPIPort::Type , speed : i32 ) ; } extern "C" { 
 /// Sets the SPI options.
///
/// @param port             The number of the port to use. 0-3 for Onboard
/// CS0-CS2, 4 for MXP
/// @param msbFirst         True to write the MSB first, False for LSB first
/// @param sampleOnTrailing True to sample on the trailing edge, False to sample
/// on the leading edge
/// @param clkIdleHigh      True to set the clock to active low, False to set the
/// clock active high 
 pub fn HAL_SetSPIOpts ( port : HAL_SPIPort::Type , msbFirst : HAL_Bool , sampleOnTrailing : HAL_Bool , clkIdleHigh : HAL_Bool ) ; } extern "C" { 
 /// Sets the CS Active high for a SPI port.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for MXP 
 pub fn HAL_SetSPIChipSelectActiveHigh ( port : HAL_SPIPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Sets the CS Active low for a SPI port.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for MXP 
 pub fn HAL_SetSPIChipSelectActiveLow ( port : HAL_SPIPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Gets the stored handle for a SPI port.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for MXP
/// @return     The stored handle for the SPI port. 0 represents no stored
/// handle. 
 pub fn HAL_GetSPIHandle ( port : HAL_SPIPort::Type ) -> i32 ; } extern "C" { 
 /// Sets the stored handle for a SPI port.
///
/// @param port   The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP.
/// @param handle The value of the handle for the port. 
 pub fn HAL_SetSPIHandle ( port : HAL_SPIPort::Type , handle : i32 ) ; } extern "C" { 
 /// Initializes the SPI automatic accumulator.
///
/// @param port       The number of the port to use. 0-3 for Onboard CS0-CS2, 4
/// for MXP.
/// @param bufferSize The accumulator buffer size. 
 pub fn HAL_InitSPIAuto ( port : HAL_SPIPort::Type , bufferSize : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Frees an SPI automatic accumulator.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP. 
 pub fn HAL_FreeSPIAuto ( port : HAL_SPIPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Sets the period for automatic SPI accumulation.
///
/// @param port   The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP.
/// @param period The accumlation period (seconds). 
 pub fn HAL_StartSPIAutoRate ( port : HAL_SPIPort::Type , period : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Starts the auto SPI accumulator on a specific trigger.
///
/// Note that triggering on both rising and falling edges is a valid
/// configuration.
///
/// @param port                The number of the port to use. 0-3 for Onboard
/// CS0-CS2, 4 for MXP.
/// @param digitalSourceHandle The trigger source to use (Either
/// HAL_AnalogTriggerHandle or HAL_DigitalHandle).
/// @param analogTriggerType   The analog trigger type, if the source is an
/// analog trigger.
/// @param triggerRising       Trigger on the rising edge if true.
/// @param triggerFalling      Trigger on the falling edge if true. 
 pub fn HAL_StartSPIAutoTrigger ( port : HAL_SPIPort::Type , digitalSourceHandle : HAL_Handle , analogTriggerType : HAL_AnalogTriggerType::Type , triggerRising : HAL_Bool , triggerFalling : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Stops an automatic SPI accumlation.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP. 
 pub fn HAL_StopSPIAuto ( port : HAL_SPIPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Sets the data to be transmitted to the device to initiate a read.
///
/// @param port       The number of the port to use. 0-3 for Onboard CS0-CS2, 4
/// for MXP.
/// @param dataToSend Pointer to the data to send (Gets copied for continue use,
/// so no need to keep alive).
/// @param dataSize   The length of the data to send.
/// @param zeroSize   The number of zeros to send after the data. 
 pub fn HAL_SetSPIAutoTransmitData ( port : HAL_SPIPort::Type , dataToSend : * const u8 , dataSize : i32 , zeroSize : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Immediately forces an SPI read to happen.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP. 
 pub fn HAL_ForceSPIAutoRead ( port : HAL_SPIPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Reads data received by the SPI accumulator.
///
/// @param port      The number of the port to use. 0-3 for Onboard CS0-CS2, 4
/// for MXP.
/// @param buffer    The buffer to store the data into.
/// @param numToRead The number of bytes to read.
/// @param timeout   The read timeout (in seconds).
/// @return          The number of bytes actually read. 
 pub fn HAL_ReadSPIAutoReceivedData ( port : HAL_SPIPort::Type , buffer : * mut u8 , numToRead : i32 , timeout : f64 , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the count of how many SPI accumulations have been missed.
///
/// @param port The number of the port to use. 0-3 for Onboard CS0-CS2, 4 for
/// MXP.
/// @return     The number of missed accumulations. 
 pub fn HAL_GetSPIAutoDroppedCount ( port : HAL_SPIPort::Type , status : * mut i32 ) -> i32 ; } pub mod HAL_SerialPort { 
 /// @defgroup hal_serialport Serial Port Functions
/// @ingroup hal_capi
/// @{ 
 pub type Type = i32 ; pub const HAL_SerialPort_Onboard : Type = 0 ; pub const HAL_SerialPort_MXP : Type = 1 ; pub const HAL_SerialPort_USB1 : Type = 2 ; pub const HAL_SerialPort_USB2 : Type = 3 ; } extern "C" { 
 /// Initializes a serial port.
///
/// The channels are either the onboard RS232, the mxp uart, or 2 USB ports. The
/// top port is USB1, the bottom port is USB2.
///
/// @param port the serial port to initialize 
 pub fn HAL_InitializeSerialPort ( port : HAL_SerialPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Initializes a serial port with a direct name.
///
/// This name is the VISA name for a specific port (find this in the web dash).
/// Note these are not always consistent between roboRIO reboots.
///
/// @param port     the serial port to initialize
/// @param portName the VISA port name 
 pub fn HAL_InitializeSerialPortDirect ( port : HAL_SerialPort::Type , portName : * const :: std :: os :: raw :: c_char , status : * mut i32 ) ; } extern "C" { 
 /// Sets the baud rate of a serial port.
///
/// Any value between 0 and 0xFFFFFFFF may be used. Default is 9600.
///
/// @param port the serial port
/// @param baud the baud rate to set 
 pub fn HAL_SetSerialBaudRate ( port : HAL_SerialPort::Type , baud : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the number of data bits on a serial port.
///
/// Defaults to 8.
///
/// @param port the serial port
/// @param bits the number of data bits (5-8) 
 pub fn HAL_SetSerialDataBits ( port : HAL_SerialPort::Type , bits : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the number of parity bits on a serial port.
///
/// Valid values are:
///   0: None (default)
///   1: Odd
///   2: Even
///   3: Mark - Means exists and always 1
///   4: Space - Means exists and always 0
///
/// @param port   the serial port
/// @param parity the parity bit mode (see remarks for valid values) 
 pub fn HAL_SetSerialParity ( port : HAL_SerialPort::Type , parity : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the number of stop bits on a serial port.
///
/// Valid values are:
///   10: One stop bit (default)
///   15: One and a half stop bits
///   20: Two stop bits
///
/// @param port     the serial port
/// @param stopBits the stop bit value (see remarks for valid values) 
 pub fn HAL_SetSerialStopBits ( port : HAL_SerialPort::Type , stopBits : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the write mode on a serial port.
///
/// Valid values are:
///   1: Flush on access
///   2: Flush when full (default)
///
/// @param port the serial port
/// @param mode the mode to set (see remarks for valid values) 
 pub fn HAL_SetSerialWriteMode ( port : HAL_SerialPort::Type , mode : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the flow control mode of a serial port.
///
/// Valid values are:
///   0: None (default)
///   1: XON-XOFF
///   2: RTS-CTS
///   3: DTR-DSR
///
/// @param port the serial port
/// @param flow the mode to set (see remarks for valid values) 
 pub fn HAL_SetSerialFlowControl ( port : HAL_SerialPort::Type , flow : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the minimum serial read timeout of a port.
///
/// @param port    the serial port
/// @param timeout the timeout in milliseconds 
 pub fn HAL_SetSerialTimeout ( port : HAL_SerialPort::Type , timeout : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the termination character that terminates a read.
///
/// By default this is disabled.
///
/// @param port       the serial port
/// @param terminator the termination character to set 
 pub fn HAL_EnableSerialTermination ( port : HAL_SerialPort::Type , terminator : :: std :: os :: raw :: c_char , status : * mut i32 ) ; } extern "C" { 
 /// Disables a termination character for reads.
///
/// @param port the serial port 
 pub fn HAL_DisableSerialTermination ( port : HAL_SerialPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Sets the size of the read buffer.
///
/// @param port the serial port
/// @param size the read buffer size 
 pub fn HAL_SetSerialReadBufferSize ( port : HAL_SerialPort::Type , size : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the size of the write buffer.
///
/// @param port the serial port
/// @param size the write buffer size 
 pub fn HAL_SetSerialWriteBufferSize ( port : HAL_SerialPort::Type , size : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the number of bytes currently in the read buffer.
///
/// @param port the serial port
/// @return     the number of bytes in the read buffer 
 pub fn HAL_GetSerialBytesReceived ( port : HAL_SerialPort::Type , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Reads data from the serial port.
///
/// Will wait for either timeout (if set), the termination char (if set), or the
/// count to be full. Whichever one comes first.
///
/// @param port  the serial port
/// @param count the number of bytes maximum to read
/// @return      the number of bytes actually read 
 pub fn HAL_ReadSerial ( port : HAL_SerialPort::Type , buffer : * mut :: std :: os :: raw :: c_char , count : i32 , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Writes data to the serial port.
///
/// @param port   the serial port
/// @param buffer the buffer to write
/// @param count  the number of bytes to write from the buffer
/// @return       the number of bytes actually written 
 pub fn HAL_WriteSerial ( port : HAL_SerialPort::Type , buffer : * const :: std :: os :: raw :: c_char , count : i32 , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Flushes the serial write buffer out to the port.
///
/// @param port the serial port 
 pub fn HAL_FlushSerial ( port : HAL_SerialPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Clears the receive buffer of the serial port.
///
/// @param port the serial port 
 pub fn HAL_ClearSerial ( port : HAL_SerialPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Closes a serial port.
///
/// @param port the serial port to close 
 pub fn HAL_CloseSerial ( port : HAL_SerialPort::Type , status : * mut i32 ) ; } extern "C" { 
 /// Initializes a solenoid port.
///
/// @param portHandle the port handle of the module and channel to initialize
/// @return           the created solenoid handle 
 pub fn HAL_InitializeSolenoidPort ( portHandle : HAL_PortHandle , status : * mut i32 ) -> HAL_SolenoidHandle ; } extern "C" { 
 /// Frees a solenoid port.
///
/// @param solenoidPortHandle the solenoid handle 
 pub fn HAL_FreeSolenoidPort ( solenoidPortHandle : HAL_SolenoidHandle ) ; } extern "C" { 
 /// Checks if a solenoid module is in the valid range.
///
/// @param module the module number to check
/// @return       true if the module number is valid, otherwise false 
 pub fn HAL_CheckSolenoidModule ( module : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Checks if a solenoid channel is in the valid range.
///
/// @param channel the channel number to check
/// @return       true if the channel number is valid, otherwise false 
 pub fn HAL_CheckSolenoidChannel ( channel : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the current solenoid output value.
///
/// @param solenoidPortHandle the solenoid handle
/// @return                   true if the solenoid is on, otherwise false 
 pub fn HAL_GetSolenoid ( solenoidPortHandle : HAL_SolenoidHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the status of all solenoids on a specific module.
///
/// @param module the module to check
/// @return       bitmask of the channels, 1 for on 0 for off 
 pub fn HAL_GetAllSolenoids ( module : i32 , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Sets a solenoid output value.
///
/// @param solenoidPortHandle the solenoid handle
/// @param value              true for on, false for off 
 pub fn HAL_SetSolenoid ( solenoidPortHandle : HAL_SolenoidHandle , value : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Sets all channels on a specific module.
///
/// @param module the module to set the channels on
/// @param state  bitmask of the channels to set, 1 for on 0 for off 
 pub fn HAL_SetAllSolenoids ( module : i32 , state : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the channels blacklisted from being enabled on a module.
///
/// @param module the module to check
/// @retur        bitmask of the blacklisted channels, 1 for true 0 for false 
 pub fn HAL_GetPCMSolenoidBlackList ( module : i32 , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets if a specific module has an over or under voltage sticky fault.
///
/// @param module the module to check
/// @return       true if a stick fault is set, otherwise false 
 pub fn HAL_GetPCMSolenoidVoltageStickyFault ( module : i32 , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if a specific module has an over or under voltage fault.
///
/// @param module the module to check
/// @return       true if faulted, otherwise false 
 pub fn HAL_GetPCMSolenoidVoltageFault ( module : i32 , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Clears all faults on a module.
///
/// @param module the module to clear 
 pub fn HAL_ClearAllPCMStickyFaults ( module : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the one shot duration on a solenoid channel.
///
/// @param solenoidPortHandle the solenoid handle
/// @param durMS              the one shot duration in ms 
 pub fn HAL_SetOneShotDuration ( solenoidPortHandle : HAL_SolenoidHandle , durMS : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Fires a single pulse on a solenoid channel.
///
/// The pulse is the duration set by HAL_SetOneShotDuration().
///
/// @param solenoidPortHandle the solenoid handle 
 pub fn HAL_FireOneShot ( solenoidPortHandle : HAL_SolenoidHandle , status : * mut i32 ) ; } pub mod HALUsageReporting_tResourceType { pub type Type = u32 ; pub const kResourceType_Controller : Type = 0 ; pub const kResourceType_Module : Type = 1 ; pub const kResourceType_Language : Type = 2 ; pub const kResourceType_CANPlugin : Type = 3 ; pub const kResourceType_Accelerometer : Type = 4 ; pub const kResourceType_ADXL345 : Type = 5 ; pub const kResourceType_AnalogChannel : Type = 6 ; pub const kResourceType_AnalogTrigger : Type = 7 ; pub const kResourceType_AnalogTriggerOutput : Type = 8 ; pub const kResourceType_CANJaguar : Type = 9 ; pub const kResourceType_Compressor : Type = 10 ; pub const kResourceType_Counter : Type = 11 ; pub const kResourceType_Dashboard : Type = 12 ; pub const kResourceType_DigitalInput : Type = 13 ; pub const kResourceType_DigitalOutput : Type = 14 ; pub const kResourceType_DriverStationCIO : Type = 15 ; pub const kResourceType_DriverStationEIO : Type = 16 ; pub const kResourceType_DriverStationLCD : Type = 17 ; pub const kResourceType_Encoder : Type = 18 ; pub const kResourceType_GearTooth : Type = 19 ; pub const kResourceType_Gyro : Type = 20 ; pub const kResourceType_I2C : Type = 21 ; pub const kResourceType_Framework : Type = 22 ; pub const kResourceType_Jaguar : Type = 23 ; pub const kResourceType_Joystick : Type = 24 ; pub const kResourceType_Kinect : Type = 25 ; pub const kResourceType_KinectStick : Type = 26 ; pub const kResourceType_PIDController : Type = 27 ; pub const kResourceType_Preferences : Type = 28 ; pub const kResourceType_PWM : Type = 29 ; pub const kResourceType_Relay : Type = 30 ; pub const kResourceType_RobotDrive : Type = 31 ; pub const kResourceType_SerialPort : Type = 32 ; pub const kResourceType_Servo : Type = 33 ; pub const kResourceType_Solenoid : Type = 34 ; pub const kResourceType_SPI : Type = 35 ; pub const kResourceType_Task : Type = 36 ; pub const kResourceType_Ultrasonic : Type = 37 ; pub const kResourceType_Victor : Type = 38 ; pub const kResourceType_Button : Type = 39 ; pub const kResourceType_Command : Type = 40 ; pub const kResourceType_AxisCamera : Type = 41 ; pub const kResourceType_PCVideoServer : Type = 42 ; pub const kResourceType_SmartDashboard : Type = 43 ; pub const kResourceType_Talon : Type = 44 ; pub const kResourceType_HiTechnicColorSensor : Type = 45 ; pub const kResourceType_HiTechnicAccel : Type = 46 ; pub const kResourceType_HiTechnicCompass : Type = 47 ; pub const kResourceType_SRF08 : Type = 48 ; pub const kResourceType_AnalogOutput : Type = 49 ; pub const kResourceType_VictorSP : Type = 50 ; pub const kResourceType_PWMTalonSRX : Type = 51 ; pub const kResourceType_CANTalonSRX : Type = 52 ; pub const kResourceType_ADXL362 : Type = 53 ; pub const kResourceType_ADXRS450 : Type = 54 ; pub const kResourceType_RevSPARK : Type = 55 ; pub const kResourceType_MindsensorsSD540 : Type = 56 ; pub const kResourceType_DigitalGlitchFilter : Type = 57 ; pub const kResourceType_ADIS16448 : Type = 58 ; pub const kResourceType_PDP : Type = 59 ; pub const kResourceType_PCM : Type = 60 ; pub const kResourceType_PigeonIMU : Type = 61 ; pub const kResourceType_NidecBrushless : Type = 62 ; pub const kResourceType_CANifier : Type = 63 ; pub const kResourceType_CTRE_future0 : Type = 64 ; pub const kResourceType_CTRE_future1 : Type = 65 ; pub const kResourceType_CTRE_future2 : Type = 66 ; pub const kResourceType_CTRE_future3 : Type = 67 ; pub const kResourceType_CTRE_future4 : Type = 68 ; pub const kResourceType_CTRE_future5 : Type = 69 ; pub const kResourceType_CTRE_future6 : Type = 70 ; pub const kResourceType_LinearFilter : Type = 71 ; pub const kResourceType_XboxController : Type = 72 ; pub const kResourceType_UsbCamera : Type = 73 ; pub const kResourceType_NavX : Type = 74 ; pub const kResourceType_Pixy : Type = 75 ; pub const kResourceType_Pixy2 : Type = 76 ; pub const kResourceType_ScanseSweep : Type = 77 ; pub const kResourceType_Shuffleboard : Type = 78 ; pub const kResourceType_CAN : Type = 79 ; pub const kResourceType_DigilentDMC60 : Type = 80 ; pub const kResourceType_PWMVictorSPX : Type = 81 ; } pub mod HALUsageReporting_tInstances { pub type Type = u32 ; pub const kLanguage_LabVIEW : Type = 1 ; pub const kLanguage_CPlusPlus : Type = 2 ; pub const kLanguage_Java : Type = 3 ; pub const kLanguage_Python : Type = 4 ; pub const kLanguage_DotNet : Type = 5 ; pub const kCANPlugin_BlackJagBridge : Type = 1 ; pub const kCANPlugin_2CAN : Type = 2 ; pub const kFramework_Iterative : Type = 1 ; pub const kFramework_Simple : Type = 2 ; pub const kFramework_CommandControl : Type = 3 ; pub const kFramework_Timed : Type = 4 ; pub const kFramework_ROS : Type = 5 ; pub const kFramework_RobotBuilder : Type = 6 ; pub const kRobotDrive_ArcadeStandard : Type = 1 ; pub const kRobotDrive_ArcadeButtonSpin : Type = 2 ; pub const kRobotDrive_ArcadeRatioCurve : Type = 3 ; pub const kRobotDrive_Tank : Type = 4 ; pub const kRobotDrive_MecanumPolar : Type = 5 ; pub const kRobotDrive_MecanumCartesian : Type = 6 ; pub const kRobotDrive2_DifferentialArcade : Type = 7 ; pub const kRobotDrive2_DifferentialTank : Type = 8 ; pub const kRobotDrive2_DifferentialCurvature : Type = 9 ; pub const kRobotDrive2_MecanumCartesian : Type = 10 ; pub const kRobotDrive2_MecanumPolar : Type = 11 ; pub const kRobotDrive2_KilloughCartesian : Type = 12 ; pub const kRobotDrive2_KilloughPolar : Type = 13 ; pub const kDriverStationCIO_Analog : Type = 1 ; pub const kDriverStationCIO_DigitalIn : Type = 2 ; pub const kDriverStationCIO_DigitalOut : Type = 3 ; pub const kDriverStationEIO_Acceleration : Type = 1 ; pub const kDriverStationEIO_AnalogIn : Type = 2 ; pub const kDriverStationEIO_AnalogOut : Type = 3 ; pub const kDriverStationEIO_Button : Type = 4 ; pub const kDriverStationEIO_LED : Type = 5 ; pub const kDriverStationEIO_DigitalIn : Type = 6 ; pub const kDriverStationEIO_DigitalOut : Type = 7 ; pub const kDriverStationEIO_FixedDigitalOut : Type = 8 ; pub const kDriverStationEIO_PWM : Type = 9 ; pub const kDriverStationEIO_Encoder : Type = 10 ; pub const kDriverStationEIO_TouchSlider : Type = 11 ; pub const kADXL345_SPI : Type = 1 ; pub const kADXL345_I2C : Type = 2 ; pub const kCommand_Scheduler : Type = 1 ; pub const kSmartDashboard_Instance : Type = 1 ; } pub mod HAL_RuntimeType { 
 /// @defgroup hal_capi WPILib HAL API
/// Hardware Abstraction Layer to hardware or simulator
/// @{ 
 pub type Type = i32 ; pub const HAL_Athena : Type = 0 ; pub const HAL_Mock : Type = 1 ; } extern "C" { 
 /// Gets the error message for a specific status code.
///
/// @param code the status code
/// @return     the error message for the code. This does not need to be freed. 
 pub fn HAL_GetErrorMessage ( code : i32 ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { 
 /// Returns the FPGA Version number.
///
/// For now, expect this to be competition year.
///
/// @return FPGA Version number. 
 pub fn HAL_GetFPGAVersion ( status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Returns the FPGA Revision number.
///
/// The format of the revision is 3 numbers.
/// The 12 most significant bits are the Major Revision.
/// the next 8 bits are the Minor Revision.
/// The 12 least significant bits are the Build Number.
///
/// @return FPGA Revision number. 
 pub fn HAL_GetFPGARevision ( status : * mut i32 ) -> i64 ; } extern "C" { pub fn HAL_GetRuntimeType ( ) -> HAL_RuntimeType::Type ; } extern "C" { 
 /// Gets the state of the "USER" button on the roboRIO.
///
/// @return true if the button is currently pressed down 
 pub fn HAL_GetFPGAButton ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if the system outputs are currently active
///
/// @return true if the system outputs are active, false if disabled 
 pub fn HAL_GetSystemActive ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets if the system is in a browned out state.
///
/// @return true if the system is in a low voltage brown out, false otherwise 
 pub fn HAL_GetBrownedOut ( status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// The base HAL initialize function. Useful if you need to ensure the DS and
/// base HAL functions (the ones above this declaration in HAL.h) are properly
/// initialized. For normal programs and executables, please use HAL_Initialize.
///
/// This is mainly expected to be use from libraries that are expected to be used
/// from LabVIEW, as it handles its own initialization for objects. 
 pub fn HAL_BaseInitialize ( status : * mut i32 ) ; } extern "C" { 
 /// Gets a port handle for a specific channel.
///
/// The created handle does not need to be freed.
///
/// @param channel the channel number
/// @return        the created port 
 pub fn HAL_GetPort ( channel : i32 ) -> HAL_PortHandle ; } extern "C" { 
 /// Gets a port handle for a specific channel and module.
///
/// This is expected to be used for PCMs, as the roboRIO does not work with
/// modules anymore.
///
/// The created handle does not need to be freed.
///
/// @param module  the module number
/// @param channel the channel number
/// @return        the created port 
 pub fn HAL_GetPortWithModule ( module : i32 , channel : i32 ) -> HAL_PortHandle ; } extern "C" { 
 /// Reads the microsecond-resolution timer on the FPGA.
///
/// @return The current time in microseconds according to the FPGA (since FPGA
/// reset). 
 pub fn HAL_GetFPGATime ( status : * mut i32 ) -> u64 ; } extern "C" { 
 /// Call this to start up HAL. This is required for robot programs.
///
/// This must be called before any other HAL functions. Failure to do so will
/// result in undefined behavior, and likely segmentation faults. This means that
/// any statically initialized variables in a program MUST call this function in
/// their constructors if they want to use other HAL calls.
///
/// The common parameters are 500 for timeout and 0 for mode.
///
/// This function is safe to call from any thread, and as many times as you wish.
/// It internally guards from any reentrancy.
///
/// The applicable modes are:
///   0: Try to kill an existing HAL from another program, if not successful,
/// error.
///   1: Force kill a HAL from another program.
///   2: Just warn if another hal exists and cannot be killed. Will likely result
/// in undefined behavior.
///
/// @param timeout the initialization timeout (ms)
/// @param mode    the initialization mode (see remarks)
/// @return        true if initialization was successful, otherwise false. 
 pub fn HAL_Initialize ( timeout : i32 , mode : i32 ) -> HAL_Bool ; } extern "C" { 
 /// Reports a hardware usage to the HAL.
///
/// @param resource       the used resource
/// @param instanceNumber the instance of the resource
/// @param context        a user specified context index
/// @param feature        a user specified feature string
/// @return               the index of the added value in NetComm 
 pub fn HAL_Report ( resource : i32 , instanceNumber : i32 , context : i32 , feature : * const :: std :: os :: raw :: c_char ) -> i64 ; } pub mod HAL_EncoderIndexingType { 
 /// The type of index pulse for the encoder. 
 pub type Type = i32 ; pub const HAL_kResetWhileHigh : Type = 0 ; pub const HAL_kResetWhileLow : Type = 1 ; pub const HAL_kResetOnFallingEdge : Type = 2 ; pub const HAL_kResetOnRisingEdge : Type = 3 ; } pub mod HAL_EncoderEncodingType { 
 /// The encoding scaling of the encoder. 
 pub type Type = i32 ; pub const HAL_Encoder_k1X : Type = 0 ; pub const HAL_Encoder_k2X : Type = 1 ; pub const HAL_Encoder_k4X : Type = 2 ; } extern "C" { 
 /// Initializes an encoder.
///
/// @param digitalSourceHandleA the A source (either a HAL_DigitalHandle or a
/// HAL_AnalogTriggerHandle)
/// @param analogTriggerTypeA   the analog trigger type of the A source if it is
/// an analog trigger
/// @param digitalSourceHandleB the B source (either a HAL_DigitalHandle or a
/// HAL_AnalogTriggerHandle)
/// @param analogTriggerTypeB   the analog trigger type of the B source if it is
/// an analog trigger
/// @param reverseDirection     true to reverse the counting direction from
/// standard, otherwise false
/// @param encodingType         the encoding type
///@return                     the created encoder handle 
 pub fn HAL_InitializeEncoder ( digitalSourceHandleA : HAL_Handle , analogTriggerTypeA : HAL_AnalogTriggerType::Type , digitalSourceHandleB : HAL_Handle , analogTriggerTypeB : HAL_AnalogTriggerType::Type , reverseDirection : HAL_Bool , encodingType : HAL_EncoderEncodingType::Type , status : * mut i32 ) -> HAL_EncoderHandle ; } extern "C" { 
 /// Frees an encoder.
///
/// @param encoderHandle the encoder handle 
 pub fn HAL_FreeEncoder ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) ; } extern "C" { 
 /// Gets the current counts of the encoder after encoding type scaling.
///
/// This is scaled by the value passed duing initialization to encodingType.
///
/// @param encoderHandle the encoder handle
/// @return the current scaled count 
 pub fn HAL_GetEncoder ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the raw counts of the encoder.
///
/// This is not scaled by any values.
///
/// @param encoderHandle the encoder handle
/// @return              the raw encoder count 
 pub fn HAL_GetEncoderRaw ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the encoder scale value.
///
/// This is set by the value passed during initialization to encodingType.
///
/// @param encoderHandle the encoder handle
/// @return              the encoder scale value 
 pub fn HAL_GetEncoderEncodingScale ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Reads the current encoder value.
///
/// Read the value at this instant. It may still be running, so it reflects the
/// current value. Next time it is read, it might have a different value.
///
/// @param encoderHandle the encoder handle
/// @return              the current encoder value 
 pub fn HAL_ResetEncoder ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) ; } extern "C" { pub fn HAL_GetEncoderPeriod ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Sets the maximum period where the device is still considered "moving".
///
/// Sets the maximum period where the device is considered moving. This value is
/// used to determine the "stopped" state of the encoder using the
/// HAL_GetEncoderStopped method.
///
/// @param encoderHandle the encoder handle
/// @param maxPeriod     the maximum period where the counted device is
/// considered moving in seconds 
 pub fn HAL_SetEncoderMaxPeriod ( encoderHandle : HAL_EncoderHandle , maxPeriod : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Determines if the clock is stopped.
///
/// Determines if the clocked input is stopped based on the MaxPeriod value set
/// using the SetMaxPeriod method. If the clock exceeds the MaxPeriod, then the
/// device (and encoder) are assumed to be stopped and it returns true.
///
/// @param encoderHandle the encoder handle
/// @return              true if the most recent encoder period exceeds the
/// MaxPeriod value set by SetMaxPeriod 
 pub fn HAL_GetEncoderStopped ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the last direction the encoder value changed.
///
/// @param encoderHandle the encoder handle
/// @return              the last direction the encoder value changed 
 pub fn HAL_GetEncoderDirection ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> HAL_Bool ; } extern "C" { 
 /// Gets the current distance traveled by the encoder.
///
/// This is the encoder count scaled by the distance per pulse set for the
/// encoder.
///
/// @param encoderHandle the encoder handle
/// @return              the encoder distance (units are determined by the units
/// passed to HAL_SetEncoderDistancePerPulse) 
 pub fn HAL_GetEncoderDistance ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the current rate of the encoder.
///
/// This is the encoder period scaled by the distance per pulse set for the
/// encoder.
///
/// @param encoderHandle the encoder handle
/// @return              the encoder rate (units are determined by the units
/// passed to HAL_SetEncoderDistancePerPulse, time value is seconds) 
 pub fn HAL_GetEncoderRate ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Sets the minimum rate to be considered moving by the encoder.
///
/// Units need to match what is set by HAL_SetEncoderDistancePerPulse, with time
/// as seconds.
///
/// @param encoderHandle the encoder handle
/// @param minRate       the minimum rate to be considered moving (units are
/// determined by the units passed to HAL_SetEncoderDistancePerPulse, time value
/// is seconds) 
 pub fn HAL_SetEncoderMinRate ( encoderHandle : HAL_EncoderHandle , minRate : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Sets the distance traveled per encoder pulse. This is used as a scaling
/// factor for the rate and distance calls.
///
/// @param encoderHandle    the encoder handle
/// @param distancePerPulse the distance traveled per encoder pulse (units user
/// defined) 
 pub fn HAL_SetEncoderDistancePerPulse ( encoderHandle : HAL_EncoderHandle , distancePerPulse : f64 , status : * mut i32 ) ; } extern "C" { 
 /// Sets if to reverse the direction of the encoder.
///
/// Note that this is not a toggle. It is an absolute set.
///
/// @param encoderHandle    the encoder handle
/// @param reverseDirection true to reverse the direction, false to not. 
 pub fn HAL_SetEncoderReverseDirection ( encoderHandle : HAL_EncoderHandle , reverseDirection : HAL_Bool , status : * mut i32 ) ; } extern "C" { 
 /// Sets the number of encoder samples to average when calculating encoder rate.
///
/// @param encoderHandle    the encoder handle
/// @param samplesToAverage the number of samples to average 
 pub fn HAL_SetEncoderSamplesToAverage ( encoderHandle : HAL_EncoderHandle , samplesToAverage : i32 , status : * mut i32 ) ; } extern "C" { 
 /// Gets the current samples to average value.
///
/// @param encoderHandle the encoder handle
/// @return              the current samples to average value 
 pub fn HAL_GetEncoderSamplesToAverage ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Sets the source for an index pulse on the encoder.
///
/// The index pulse can be used to cause an encoder to reset based on an external
/// input.
///
/// @param encoderHandle       the encoder handle
/// @param digitalSourceHandle the index source handle (either a
/// HAL_AnalogTriggerHandle of a HAL_DigitalHandle)
/// @param analogTriggerType   the analog trigger type if the source is an analog
/// trigger
/// @param type                the index triggering type 
 pub fn HAL_SetEncoderIndexSource ( encoderHandle : HAL_EncoderHandle , digitalSourceHandle : HAL_Handle , analogTriggerType : HAL_AnalogTriggerType::Type , type_ : HAL_EncoderIndexingType::Type , status : * mut i32 ) ; } extern "C" { 
 /// Gets the FPGA index of the encoder.
///
/// @param encoderHandle the encoder handle
/// @return              the FPGA index of the encoder 
 pub fn HAL_GetEncoderFPGAIndex ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> i32 ; } extern "C" { 
 /// Gets the decoding scale factor of the encoder.
///
/// This is used to perform the scaling from raw to type scaled values.
///
/// @param encoderHandle the encoder handle
/// @return              the scale value for the encoder 
 pub fn HAL_GetEncoderDecodingScaleFactor ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the user set distance per pulse of the encoder.
///
/// @param encoderHandle the encoder handle
/// @return              the set distance per pulse 
 pub fn HAL_GetEncoderDistancePerPulse ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> f64 ; } extern "C" { 
 /// Gets the encoding type of the encoder.
///
/// @param encoderHandle the encoder handle
/// @return              the encoding type 
 pub fn HAL_GetEncoderEncodingType ( encoderHandle : HAL_EncoderHandle , status : * mut i32 ) -> HAL_EncoderEncodingType::Type ; }