Acelerómetros-Software

Nota

Esta sección cubre los acelerómetros en el software. Para obtener una guía de hardware para acelerómetros, consulte Acelerómetros - Hardware.

Un acelerómetro es un dispositivo que mide la aceleración.

Los acelerómetros generalmente vienen en dos tipos: eje único y eje 3. Un acelerómetro de un solo eje mide la aceleración a lo largo de una dimensión espacial; un acelerómetro de 3 ejes mide aceleración a lo largo de las tres dimensiones espaciales a la vez.

WPILib admite acelerómetros de eje único a través de la clase AnalogAccelerometer.

Los acelerómetros de tres ejes a menudo requieren protocolos de comunicación más complicados (como SPI o I2C) para enviar datos multidimensionales. WPILib tiene soporte nativo para los siguientes acelerómetros de 3 ejes:

AnalogAccelerometer

The AnalogAccelerometer class (Java, C++) allows users to read values from a single-axis accelerometer that is connected to one of the roboRIO’s analog inputs.

// Creates an analog accelerometer on analog input 0
AnalogAccelerometer accelerometer = new AnalogAccelerometer(0);

// Sets the sensitivity of the accelerometer to 1 volt per G
accelerometer.setSensitivity(1);

// Sets the zero voltage of the accelerometer to 3 volts
accelerometer.setZero(3);

// Gets the current acceleration
double accel = accelerometer.getAcceleration();

// Creates an analog accelerometer on analog input 0
frc::AnalogAccelerometer accelerometer{0};

// Sets the sensitivity of the accelerometer to 1 volt per G
accelerometer.SetSensitivity(1);

// Sets the zero voltage of the accelerometer to 3 volts
accelerometer.SetZero(3);

// Gets the current acceleration
double accel = accelerometer.GetAcceleration();

Si los usuarios cuentan cuentan con un acelerómetro de 3 ejes, se pueden usar tres instancias de esta clase, una para cada eje.

There are getters for the acceleration along each cardinal direction (x, y, and z), as well as a setter for the range of accelerations the accelerometer will measure.

// Sets the accelerometer to measure between -8 and 8 G's
accelerometer.setRange(BuiltInAccelerometer.Range.k8G);

// Sets the accelerometer to measure between -8 and 8 G's
accelerometer.SetRange(BuiltInAccelerometer::Range::kRange_8G);

ADXL345_I2C

The ADXL345_I2C class (Java, C++) provides support for the ADXL345 accelerometer over the I2C communications bus.

// Creates an ADXL345 accelerometer object on the MXP I2C port
// with a measurement range from -8 to 8 G's
ADXL345_I2C accelerometer = new ADXL345_I2C(I2C.Port.kMXP, ADXL345_I2C.Range.k8G);

// Creates an ADXL345 accelerometer object on the MXP I2C port
// with a measurement range from -8 to 8 G's
frc::ADXL345_I2C accelerometer{I2C::Port::kMXP, frc::ADXL345_I2C::Range::kRange_8G};

ADXL345_SPI

The ADXL345_SPI class (Java, C++) provides support for the ADXL345 accelerometer over the SPI communications bus.

// Creates an ADXL345 accelerometer object on the MXP SPI port
// with a measurement range from -8 to 8 G's
ADXL345_SPI accelerometer = new ADXL345_SPI(SPI.Port.kMXP, ADXL345_SPI.Range.k8G);

// Creates an ADXL345 accelerometer object on the MXP SPI port
// with a measurement range from -8 to 8 G's
frc::ADXL345_SPI accelerometer{SPI::Port::kMXP, frc::ADXL345_SPI::Range::kRange_8G};

ADXL362

The ADXL362 class (Java, C++) provides support for the ADXL362 accelerometer over the SPI communications bus.

// Creates an ADXL362 accelerometer object on the MXP SPI port
// with a measurement range from -8 to 8 G's
ADXL362 accelerometer = new ADXL362(SPI.Port.kMXP, ADXL362.Range.k8G);

// Creates an ADXL362 accelerometer object on the MXP SPI port
// with a measurement range from -8 to 8 G's
frc::ADXL362 accelerometer{SPI::Port::kMXP, frc::ADXL362::Range::kRange_8G};

BuiltInAccelerometer

The BuiltInAccelerometer class (Java, C++) provides access to the roboRIO’s own built-in accelerometer:

// Creates an object for the built-in accelerometer
// Range defaults to +- 8 G's
BuiltInAccelerometer accelerometer = new BuiltInAccelerometer();

// Creates an object for the built-in accelerometer
// Range defaults to +- 8 G's
frc::BuiltInAccelerometer accelerometer;

Acelerómetros de terceros

Así como WPILib provee soporte nativo para un numero de acelerómetros disponibles en el kit of parts o por medio de FIRST Choice, hay también dispositivos menos populares AHRS (Attitude and Heading Reference System) los cuales son comúnmente usados en FRC e incluyen acelerómetros. Estos son controlados generalmente mediante un vendor de libraries, aunque si tienen una entrada análoga sencilla, se pueden usar con la clase AnalogAccelerometer.

Usar acelerómetros en código

Nota

Los acelerómetros, como su nombre lo dice, miden la aceleración. Acelerómetros precisos pueden ser útiles para determinar posiciones a través de la doble integración (desde que la aceleración es la segunda derivada de la posición), de manera similar que los giroscopios son usados para determinar la dirección. Sin embargo, los acelerómetros disponibles para usar en FRC no son de la calidad suficiente para usarse de este modo.

Se recomienda utilizar acelerómetros en FRC® para cualquier aplicación que necesite una medición aproximada de la aceleración actual. Esto puede incluir la detección de colisiones con otros robots o elementos de campo, de modo que los mecanismos vulnerables se puedan retraer automáticamente. También se pueden usar para determinar cuándo el robot pasa por un terreno accidentado para una rutina autónoma (como atravesar las defensas en FIRST Stronghold).

Para detectar colisiones, a menudo es más robusto medir la sobreaceleración que la aceleración. La sobreaceleración es la derivada (o la tasa de cambio) de la aceleración e indica la rapidez con la que cambian las fuerzas sobre el robot: el impulso repentino de una colisión provoca un pico agudo en la sacudida. La sobreaceleración se puede determinar simplemente tomando la diferencia de las mediciones de aceleración posteriores y dividiéndolas por el tiempo entre ellas:

double prevXAccel = 0.0;
double prevYAccel = 0.0;

BuiltInAccelerometer accelerometer = new BuiltInAccelerometer();

@Override
public void robotPeriodic() {
    // Gets the current accelerations in the X and Y directions
    double xAccel = accelerometer.getX();
    double yAccel = accelerometer.getY();

    // Calculates the jerk in the X and Y directions
    // Divides by .02 because default loop timing is 20ms
    double xJerk = (xAccel - prevXAccel) / 0.02;
    double yJerk = (yAccel - prevYAccel) / 0.02;

    prevXAccel = xAccel;
    prevYAccel = yAccel;
}

double prevXAccel = 0.0;
double prevYAccel = 0.0;

frc::BuiltInAccelerometer accelerometer;

void Robot::RobotPeriodic() {
    // Gets the current accelerations in the X and Y directions
    double xAccel = accelerometer.GetX();
    double yAccel = accelerometer.GetY();

    // Calculates the jerk in the X and Y directions
    // Divides by .02 because default loop timing is 20ms
    double xJerk = (xAccel - prevXAccel) / 0.02;
    double yJerk = (yAccel - prevYAccel) / 0.02;

    prevXAccel = xAccel;
    prevYAccel = yAccel;
}

Most accelerometers legal for FRC use are quite noisy, and it is often a good idea to combine them with the LinearFilter class (Java, C++) to reduce the noise:

BuiltInAccelerometer accelerometer = new BuiltInAccelerometer();

// Create a LinearFilter that will calculate a moving average of the measured X acceleration over the past 10 iterations of the main loop

LinearFilter xAccelFilter = LinearFilter.movingAverage(10);

@Override
public void robotPeriodic() {
    // Get the filtered X acceleration
    double filteredXAccel = xAccelFilter.calculate(accelerometer.getX());
}

frc::BuiltInAccelerometer accelerometer;

// Create a LinearFilter that will calculate a moving average of the measured X acceleration over the past 10 iterations of the main loop
auto xAccelFilter = frc::LinearFilter::MovingAverage(10);

void Robot::RobotPeriodic() {
    // Get the filtered X acceleration
    double filteredXAccel = xAccelFilter.Calculate(accelerometer.GetX());
}