Acelerómetros, giroscopios e IMU

01 · Punto de partida

Sentir el movimiento

Los sensores de distancia y presencia de los temas anteriores miran hacia afuera. Los sensores inerciales miran hacia adentro: no necesitan ver nada del entorno, solo sienten cómo se mueve el propio dispositivo. Están en cada teléfono (para girar la pantalla), en los drones (para mantenerse estables), en las pulseras de actividad (para contar pasos), en los automóviles (para disparar el airbag) y en los robots (para saber si se inclinaron). Con dos de ellos se resuelve casi todo:

• El acelerómetro mide aceleración en tres ejes (X, Y, Z), incluida la de la gravedad.
• El giroscopio mide la velocidad angular, es decir, qué tan rápido gira alrededor de cada eje.

Un módulo con ambos se llama IMU (inertial measurement unit) de seis ejes (6 DoF, grados de libertad). Si además lleva un magnetómetro (tema 24), son nueve ejes. El MPU-6050 es el IMU de seis ejes más difundido en proyectos educativos: barato, con I2C y con una abundante documentación.

02 · Principio

Cómo miden los sensores MEMS

Los acelerómetros y giroscopios de uso corriente son MEMS (sistemas micro-electromecánicos): estructuras mecánicas microscópicas grabadas en silicio, junto con la electrónica que las lee. Se fabrican en masa con las técnicas de los circuitos integrados, por eso son pequeños, baratos y de bajo consumo.

El acelerómetro

En su forma más simple es una pequeña masa de prueba suspendida de resortes de silicio entre placas fijas. Al acelerar el chip, la masa se retrasa por inercia y se desplaza respecto de las placas; el cambio de capacidad eléctrica entre masa y placas es proporcional a esa deformación, y por lo tanto a la aceleración. Se repite en los tres ejes.

Una consecuencia fundamental: el acelerómetro no mide «la aceleración del movimiento» sino la fuerza específica sobre la masa, que incluye la gravedad. Con el dispositivo quieto sobre una mesa, la masa es empujada por el soporte hacia arriba y el sensor lee +1 g en el eje vertical (1 g = 9,80665 m/s²). En caída libre la masa y la caja caen igual, no hay deformación y el sensor lee cero en los tres ejes. Eso permite detectar caídas y, por la dirección de la gravedad, la inclinación.

El giroscopio

Un giroscopio MEMS es una masa que vibra de forma continua en una dirección. Cuando el chip gira, la fuerza de Coriolis desvía la masa en dirección perpendicular, y esa desviación (proporcional a la velocidad de giro) se mide con el mismo método capacitivo. Entrega velocidad angular en grados por segundo (°/s), no el ángulo: para obtener el ángulo hay que integrar en el tiempo (sección 06).

03 · El módulo

El MPU-6050 por I2C

El MPU-6050 integra un acelerómetro de tres ejes, un giroscopio de tres ejes y un sensor de temperatura, con conversores de 16 bits. Se comunica por I2C con la dirección 0x68 (pin AD0 a masa) o 0x69 (AD0 a Vcc). Sus registros principales (de la hoja del fabricante):

Los 14 bytes de datos están contiguos, empezando en 0x3B, de modo que una sola lectura en ráfaga entrega todo: aceleración (6 bytes), temperatura (2) y giroscopio (6). Es lo recomendable, porque las seis magnitudes corresponden entonces al mismo instante. Cada valor es un entero de 16 bits con signo (complemento a dos), con el byte alto primero. Las conversiones son:

#include <Wire.h>

const uint8_t MPU = 0x68;
const float SENS_ACEL = 16384.0;       // LSB por g, con ±2 g
const float SENS_GIRO = 131.0;         // LSB por °/s, con ±250 °/s

void mpuEscribir(uint8_t reg, uint8_t valor) {
    Wire.beginTransmission(MPU);
    Wire.write(reg);
    Wire.write(valor);
    Wire.endTransmission();
}

bool mpuIniciar() {
    Wire.beginTransmission(MPU);
    Wire.write(0x75);                              // WHO_AM_I
    if (Wire.endTransmission(false) != 0) return false;
    if (Wire.requestFrom(MPU, (uint8_t)1) != 1 || Wire.read() != 0x68) return false;

    mpuEscribir(0x6B, 0x00);                       // salir del modo de suspensión
    mpuEscribir(0x1A, 0x03);                       // filtro digital de ≈ 44 Hz
    mpuEscribir(0x1C, 0x00);                       // ±2 g
    mpuEscribir(0x1B, 0x00);                       // ±250 °/s
    return true;
}

bool mpuLeer(float &ax, float &ay, float &az, float &temp, float &gx, float &gy, float &gz) {
    Wire.beginTransmission(MPU);
    Wire.write(0x3B);                              // primer registro de datos
    if (Wire.endTransmission(false) != 0) return false;
    if (Wire.requestFrom(MPU, (uint8_t)14) != 14) return false;

    int16_t v[7];
    for (uint8_t i = 0; i < 7; i++) {
        uint8_t alto = Wire.read();                // byte alto primero
        uint8_t bajo = Wire.read();
        v[i] = (int16_t)((alto << 8) | bajo);
    }
    ax = v[0] / SENS_ACEL;  ay = v[1] / SENS_ACEL;  az = v[2] / SENS_ACEL;
    temp = v[3] / 340.0 + 36.53;
    gx = v[4] / SENS_GIRO;  gy = v[5] / SENS_GIRO;  gz = v[6] / SENS_GIRO;
    return true;
}

Dos detalles de robustez. El chip arranca dormido: si no se escribe 0 en PWR_MGMT_1, todas las lecturas valen cero y parece que el sensor no funciona. Y la ráfaga garantiza que las seis magnitudes sean coherentes entre sí; leerlas con transacciones separadas puede mezclar valores de instantes distintos.

El filtro pasa-bajos digital (registro CONFIG) limita el ancho de banda y reduce el ruido a cambio de un retardo: con el valor 3 el ancho de banda es de unos 44 Hz para el acelerómetro y 42 Hz para el giroscopio; con 6, unos 5 Hz. El ritmo de muestreo se fija con un divisor (SMPLRT_DIV). Lo que se elige depende de la aplicación: para un inclinómetro lento, un filtro fuerte; para un dron, un ancho de banda alto y poco retardo. La temperatura que entrega es la del chip, sirve para compensar derivas, no para medir el ambiente.

04 · Elegir la escala

Rangos, sensibilidad y saturación

Como en el ADC (tema 4), el rango fija un compromiso. Con 16 bits, cada rango reparte los 65 536 valores entre sus extremos: un rango pequeño da más resolución y satura con aceleraciones o giros grandes; uno grande no satura, pero cada paso representa más.

Pero la resolución nominal no es la exactitud: el ruido y el sesgo del sensor son mucho mayores que 0,06 mg, y lo que limita la medición es el ruido. Algunas referencias de orden de magnitud para elegir el rango:

• Inclinómetro, equilibrio de un robot: ±2 g (la gravedad vale 1 g y los movimientos suaves, pocas décimas).
• Gestos de la mano y actividad humana: ±4 a ±8 g.
• Impactos, aterrizajes de un dron, golpes: ±16 g o más. Un golpe puede superar 10 g.
• Giros lentos (un robot que orienta una antena): ±250 °/s. Un dron en maniobra o un giro brusco: ±1000 a ±2000 °/s.

Al superar el rango, la lectura se satura en ±32 767 y deja de ser válida: un golpe de 5 g en el rango de ±2 g aparece como 2 g, y el programa que integra el movimiento acumula un error enorme sin saberlo. Conviene detectar los valores en los extremos (|bruto| cercano a 32 767) y tratarlos como saturación.

05 · Usar la gravedad

Inclinación con el acelerómetro

Con el dispositivo quieto, el acelerómetro mide solo la gravedad, un vector de 1 g que apunta hacia abajo. Su descomposición en los tres ejes de la caja dice cómo está inclinada. Con la convención de que el cabeceo (pitch) es la inclinación hacia adelante y el alabeo (roll), hacia un costado:

Una caja horizontal lee (0, 0, 1) g: pitch y roll valen 0°. Inclinada 30° hacia adelante, lee (−0,5, 0, 0,866) g y el cálculo devuelve 30°. La fórmula usa la dirección del vector, no su módulo, por lo que no depende de la sensibilidad exacta. Tres limitaciones importan:

• Solo vale en reposo, o a velocidad constante. Cualquier aceleración lineal se suma a la gravedad y falsea el ángulo. Una caja inclinada 30° que acelera hacia adelante con 0,3 g lee (−0,2, 0, 0,866) g: el cálculo da 13°, un error de 17°.
• No mide la guiñada (yaw, el giro alrededor de la vertical): girar la caja sobre una mesa horizontal no cambia el vector de la gravedad. Para el rumbo hace falta un magnetómetro o un giroscopio.
• Pierde resolución cerca de ±90°. Como a_x = −sen θ, una variación pequeña de a_x produce un cambio de ángulo de 1/cos θ veces mayor. Con una cuenta de 1/16 384 g, un paso del ADC equivale a 0,004° a 30°, a 0,02° a 80° y a 0,2° a 89°.

float cabeceoGrados(float ax, float ay, float az) {
    return atan2(-ax, sqrt(ay * ay + az * az)) * 180.0 / PI;
}
float alabeoGrados(float ay, float az) {
    return atan2(ay, az) * 180.0 / PI;
}

Otro uso directo del acelerómetro es la detección de caídas e impactos. Con el módulo de la aceleración, |a| = √(ax² + ay² + az²), que en reposo vale 1 g: una caída libre se reconoce por |a| cerca de cero durante varias muestras, y un impacto, por un pico de varios g poco después. El módulo no depende de la orientación, lo que lo hace robusto.

06 · Integrar la rotación

Ángulo con el giroscopio y su deriva

El giroscopio da la velocidad de giro ω. El ángulo se obtiene sumando en el tiempo: en cada muestra, ángulo += ω × Δt. Si ω es de 30 °/s durante 2 s, el ángulo avanza 60°. Para giros rápidos y breves es excelente: no se confunde con las aceleraciones, responde de inmediato y tiene poco ruido. Su defecto es el sesgo (bias): aun sin girar, la salida no es cero, sino un pequeño valor constante (una fracción de °/s hasta unos pocos °/s en un sensor barato). Al integrarlo, ese error crece linealmente con el tiempo:

Una deriva de 30° por minuto vuelve inservible el ángulo del giroscopio solo en cuestión de segundos o minutos. Hay tres defensas, que se combinan: medir el sesgo en reposo y restarlo (calibración, sección siguiente), usar el giroscopio solo en tiempos cortos, y corregir lentamente con una referencia absoluta (la gravedad del acelerómetro para pitch y roll, el campo magnético para el rumbo), que es la idea de la fusión de sensores.

Además del sesgo constante hay un ruido aleatorio que, al integrarse, produce una caminata aleatoria del ángulo (angle random walk) y un sesgo que varía con la temperatura. Ni la calibración mejor elimina ambos: por eso un giroscopio barato nunca da un ángulo absoluto confiable a largo plazo.

07 · Preparar los datos

Calibración y filtrado

La calibración más rentable de un IMU es la del sesgo del giroscopio. Con el dispositivo inmóvil durante 1 a 2 segundos al arrancar, se promedian cientos de lecturas de cada eje y ese promedio se resta de todas las lecturas siguientes. Es el promedio del tema 5: reduce el ruido en √N y estima bien el sesgo. Hay que cuidar que el dispositivo realmente esté quieto durante la calibración (un temblor la estropea) y repetirla si la temperatura cambia mucho.

float sesgoGx = 0, sesgoGy = 0, sesgoGz = 0;

void calibrarGiroscopio() {                   // con el dispositivo inmóvil
    const uint16_t N = 200;
    float sx = 0, sy = 0, sz = 0;
    for (uint16_t i = 0; i < N; i++) {
        float ax, ay, az, t, gx, gy, gz;
        if (mpuLeer(ax, ay, az, t, gx, gy, gz)) { sx += gx; sy += gy; sz += gz; }
        delay(5);
    }
    sesgoGx = sx / N;  sesgoGy = sy / N;  sesgoGz = sz / N;
}

Para el acelerómetro, el sesgo y la ganancia varían unos pocos por ciento entre ejemplares. La calibración completa mide el sensor en seis posiciones (cada eje apuntando arriba y abajo) y ajusta offset y ganancia por eje; para un inclinómetro común basta comprobar que en horizontal las lecturas sean (0, 0, 1) g y corregir el offset de cada eje. Como el ángulo se obtiene de proporciones, un error de ganancia común a los tres ejes no importa; un offset sí.

Contra el ruido, los filtros del tema 5 son directos: un promedio o un filtro exponencial sobre cada eje antes de calcular el ángulo, y el filtro digital interno del MPU para limitar el ancho de banda. El compromiso es el de siempre: más suavizado, más retardo. Para el inclinómetro de una grúa, 1 segundo de retardo es aceptable; para estabilizar un dron, es un desastre.

08 · Lo que viene

Hacia la fusión de sensores

Los dos sensores se complementan de forma casi perfecta:

De ahí la idea de la fusión de sensores: confiar en el giroscopio a corto plazo y en el acelerómetro a largo plazo. El método más simple, el filtro complementario, tiene una fórmula de una línea: ángulo = α × (ángulo + ω × Δt) + (1 − α) × ánguloacel, con α cercano a 1 (por ejemplo 0,98). Cada paso integra el giroscopio y una pequeña fracción de la medición del acelerómetro tira lentamente del resultado hacia la vertical real. Existen filtros más sofisticados (Kalman, Madgwick, Mahony) que resuelven también la guiñada con un magnetómetro. El próximo tema, un taller, implementa el filtro complementario en un inclinómetro con detección de caídas.

09 · Analogía con programación

Decodificar la ráfaga, calcular ángulos y medir la deriva

Probemos la lógica del tema sin hardware. Primero, la decodificación de los 14 bytes de la ráfaga del MPU-6050 (siete enteros de 16 bits con signo, byte alto primero) con el módulo struct. Después, los ángulos de una caja inclinada y el efecto de una aceleración lineal. Por último, la deriva por un sesgo integrado a 100 Hz, con el sesgo cuantizado como lo ve el conversor.

import math
import struct

SENS_ACEL = 16384          # LSB por g (±2 g)
SENS_GIRO = 131            # LSB por °/s (±250 °/s)

# Ráfaga de 14 bytes: ax, ay, az, temperatura, gx, gy, gz (enteros de 16 bits con signo, byte alto primero)
rafaga = bytes([0x00, 0x00, 0x00, 0x00, 0x40, 0x00,       # 0, 0, +1 g
                0xF0, 0xB0,                               # temperatura
                0x00, 0x83, 0xFF, 0x7D, 0x00, 0x00])      # +1 °/s, -1 °/s, 0 °/s
ax, ay, az, temp, gx, gy, gz = struct.unpack(">7h", rafaga)
print(f"aceleración: {ax / SENS_ACEL:.3f}, {ay / SENS_ACEL:.3f}, {az / SENS_ACEL:.3f} g")
print(f"temperatura: {temp / 340 + 36.53:.1f} °C")
print(f"giroscopio:  {gx / SENS_GIRO:.2f}, {gy / SENS_GIRO:.2f}, {gz / SENS_GIRO:.2f} °/s")


def angulos(ax, ay, az):
    cabeceo = math.degrees(math.atan2(-ax, math.hypot(ay, az)))
    alabeo = math.degrees(math.atan2(ay, az))
    return cabeceo, alabeo


# ---- Inclinación en reposo y con una aceleración lineal ----
inclinacion = math.radians(30)
ax_g, ay_g, az_g = -math.sin(inclinacion), 0.0, math.cos(inclinacion)
print()
print("Caja inclinada 30° y quieta:       cabeceo = {:.1f}°, alabeo = {:.1f}°".format(*angulos(ax_g, ay_g, az_g)))
print("Con 0,3 g de aceleración hacia delante:  cabeceo = {:.1f}°".format(angulos(ax_g + 0.3, ay_g, az_g)[0]))

# ---- Deriva del giroscopio por un sesgo de 0,5 °/s, a 100 Hz, con el sesgo cuantizado ----
bruto = round(0.5 * SENS_GIRO)                           # lo que entrega el conversor
sesgo_medido = bruto / SENS_GIRO
angulo = 0.0
print()
for segundo in range(1, 61):
    for _ in range(100):
        angulo += sesgo_medido * 0.01                    # integración de ω·Δt
    if segundo in (10, 60):
        print(f"tras {segundo:2d} s sin girar: el ángulo integrado marca {angulo:5.1f}°")

# ---- Resolución del cabeceo cerca de la vertical (1 cuenta = 1/16384 g) ----
print()
for grados in (0, 30, 60, 80, 89):
    paso = math.degrees(1 / SENS_ACEL / math.cos(math.radians(grados)))
    print(f"a {grados:2d}°: un paso del acelerómetro mueve el ángulo {paso:.4f}°")

Resultado: la ráfaga decodifica 0, 0 y 1,000 g, una temperatura de 25,0 °C y giros de +1,00, −1,00 y 0,00 °/s. Una caja inclinada 30° y quieta da cabeceo 30,0° y alabeo 0,0°; con 0,3 g de aceleración hacia adelante, el cabeceo calculado baja a 13,0°, un error de 17°. Un sesgo de 0,5 °/s, cuantizado a 66 cuentas (0,504 °/s), produce 5,0° tras 10 s y 30,2° tras 60 s sin girar. La resolución del ángulo pasa de 0,0035° por paso a 0° a 0,2004° por paso a 89°: pierde resolución cerca de la vertical. Probá cambiar el sesgo a 2 °/s y mirá cuánto deriva en un minuto.

Los números de la ráfaga se construyeron a propósito; un MPU-6050 real daría pequeños valores de ruido en todos los ejes. El ejemplo ignora el ruido, la temperatura y la deriva del sesgo, por lo que es el mejor caso.

10 · Exploración interactiva

Inclinación con el acelerómetro y deriva del giroscopio

El primer instrumento simula un MPU-6050 quieto (o acelerado) con el cabeceo y el alabeo que elijas: mirá los registros crudos, los valores en g y el ángulo que calcula el programa. Podés agregar una aceleración lineal, ruido y la caída libre, y cambiar el rango para ver la saturación. El segundo integra la señal del giroscopio durante 1, 10 o 60 segundos para comparar el ángulo real con el integrado, con o sin calibración del sesgo.

Recorrido guiado

1. Con cabeceo 30°, alabeo 0° y sin aceleración: registros (−8192, 0, 14189), en g (−0,500; 0,000; 0,866), módulo 1,000 g y ángulos calculados 30,0° y 0,0°. El error es nulo.
2. Agregá 0,3 g de aceleración lineal: el cabeceo calculado baja a unos 13° (error de −17°). El módulo baja a 0,89 g. El acelerómetro no distingue la gravedad del empujón.
3. Probá el cabeceo en 85° y 89° con el ruido activado: el cabeceo calculado oscila varios grados en la medida de 89°, por la pérdida de resolución cerca de la vertical.
4. Marcá «Caída libre»: las tres lecturas valen casi cero, el módulo es cercano a 0 g y el estado indica caída libre. Los ángulos pierden sentido.
5. Con el rango en ±2 g, poné el cabeceo en −90° y la aceleración lineal en 1 g: el eje X recibe 2 g y la lectura se satura en 32 767. Pasá a ±4 g: se resuelve, con la mitad de resolución.
6. En el instrumento 2, con velocidad de giro 0 y un sesgo de 0,5 °/s sin calibrar, integrá 10 s: el programa marca unos 5° aunque no giró. Con 60 s: unos 30°.
7. Marcá «Sesgo calibrado» y repetí: el error cae a décimas de grado. Poné una velocidad de giro de 100 °/s y 10 s con el sesgo calibrado: el ángulo real es 1000° y el integrado difiere en pocos grados.
8. Con el rango de ±250 °/s, poné una velocidad real de 300 °/s: el sensor satura en 250 y el ángulo integrado queda corto. Pasá a ±500 °/s: se resuelve.

11 · Método de trabajo

Cómo elegir y usar un IMU

1. Definí qué querés saber: inclinación en reposo, detección de golpes o caídas, velocidad de giro, orientación en movimiento.
2. Elegí los rangos con las aceleraciones y giros máximos esperados, con margen, y detectá la saturación.
3. Despertá el chip (PWM_MGMT_1), verificá WHO_AM_I y leé todo en una ráfaga.
4. Elegí el filtro digital y el ritmo de muestreo según el contenido en frecuencia del movimiento.
5. Calibrá el sesgo del giroscopio al arrancar, con el dispositivo quieto, y el offset del acelerómetro en horizontal.
6. Usá el acelerómetro para inclinación solo si hay poco movimiento; usá el módulo de la aceleración para impactos y caídas.
7. Nunca uses el giroscopio solo para el ángulo absoluto a largo plazo: combinalo con una referencia (fusión).
8. Fijá el sensor con rigidez y lejos de vibraciones del motor, que inundan el acelerómetro; orientá bien los ejes respecto del sistema.
9. Validá con posiciones conocidas (mesa nivelada, escuadra) y con giros de ángulo conocido.

Si todas las lecturas valen cero, sospechá que el chip está dormido; si el ángulo «deriva», del sesgo del giroscopio; si el ángulo salta al moverse, de las aceleraciones; si hay valores atascados en 32 767, de una saturación.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Predecí antes de comprobar

1. De los registros a los g

Con el rango de ±2 g, el registro del eje Z vale 16 384 y el del eje X, −8 192. ¿Qué aceleraciones representan? ¿Y si el rango fuera de ±4 g?

2. Calcular los ángulos

Un acelerómetro quieto lee (−0,5; 0,1; 0,85) g. ¿Cuánto valen el cabeceo y el alabeo?

3. Detectar una caída

Una caja en caída libre, ¿qué lee el acelerómetro? ¿Cómo se programa la detección sin depender de la orientación?

4. Del registro al °/s

El eje X del giroscopio entrega 1310. ¿Cuántos °/s son con ±250 °/s y con ±2000 °/s?

5. Deriva

Un giroscopio quieto tiene un sesgo de 0,2 °/s que no se calibró. ¿Cuánto marca el ángulo integrado a los 5 minutos?

6. Elegir el rango

Elegí el rango del acelerómetro para: (a) un inclinómetro de una pantalla que gira; (b) detectar el aterrizaje de un dron, que puede llegar a 10 g; (c) contar los pasos de una persona (picos de 2 a 3 g).

14 · Síntesis

Ideas para recordar

¿Listo para el tema 21?

Antes de avanzar, calculá el cabeceo de una caja que lee (−0,26; 0; 0,97) g, explicá por qué un acelerómetro en caída libre lee cero y estimá la deriva de un giroscopio con 0,3 °/s de sesgo tras 2 minutos. Si podés justificar las tres respuestas, ya conocés la base de los sensores inerciales.

En el próximo tema armamos un taller: inclinómetro y detección de caída, que reúne el acelerómetro, el giroscopio, el filtro complementario y umbrales con histéresis en un único programa.