Chismes del Lince 52: El péndulo del Lince, calcular g con Arduino

Sierra Bermeja, un domingo por la tarde. El Lince de la Noche estaba en lo alto del mirador, con una piedra en cada pata y un cronómetro colgado del cuello.

—¿Qué haces? —preguntó la Gata Montesa, asomándose por una roca.

—Voy a medir la gravedad. Dicen que todo cae con la misma aceleración, 9,81 metros por segundo cada segundo. Yo quiero comprobarlo aquí, en mi sierra. Suelto la piedra, paro el cronómetro y listo.

—¿Y cuánto tarda en caer desde aquí?

—Un segundo, o así.

—Un segundo. Con un cronómetro que paras tú con la pata. Tu reflejo tarda más o menos una décima de segundo, así que te equivocarías en un diez por ciento antes de empezar.

El Lince miró la piedra con cierto resentimiento.

—Pues dime tú cómo.

—Usando un truco que ya conocía Galileo: un péndulo. Si algo cuelga de un hilo y oscila, el tiempo que tarda en ir y volver depende de la gravedad y de la longitud del hilo. Y ese tiempo se puede medir muchas veces seguidas, sin que te tiemble la pata.

—¿Y quién mide ese tiempo?

La Gata sonrió y señaló la mochila.

—Tu Arduino. Con el giroscopio que ya conoces del horizonte. Gravedad con Arduino: el sensor nota cuándo el péndulo cambia de sentido, cuenta el tiempo entre una oscilación y la siguiente y calcula g solito.

—Me estaba gustando más lo de tirar piedras —murmuró el Lince.

—Ya lo sé. Por eso estoy yo aquí.

Introducción

En este chisme calculamos la gravedad con Arduino. Colgamos un sensor MPU-6050 de un hilo, lo dejamos oscilar como un péndulo y el Arduino mide cuánto tarda en cada ida y vuelta. Con ese tiempo y la longitud del hilo, una fórmula de Primero de Bachillerato nos da el valor de g.

No hace falta un cronómetro ni una cámara. El giroscopio del sensor sabe cuándo el péndulo llega a un extremo y empieza a volver, y el Arduino anota el instante exacto, sin temblores de pulso.

El resultado es un experimento clásico de Física con medidas de verdad y un resultado que podemos comparar con el valor conocido.

Por qué este chisme

Hasta ahora los chismes con acelerómetros y giroscopios miraban hacia dónde estaba inclinada la placa, como en el nivel de burbuja con micro:bit. Aquí lo usamos para algo distinto: medir tiempo con mucha precisión y, a partir de él, una constante de la naturaleza.

Es la primera vez que un chisme se parece a un experimento de laboratorio: tenemos una hipótesis (g vale unos 9,8 m/s²), una medida repetida varias veces y un resultado que puede salir bien o mal. Y si sale mal, hay que averiguar por qué.

Cómo funciona

La Gata plantea la primera pregunta: ¿por qué un péndulo sirve para medir la gravedad? Porque lo que lo hace volver al centro es precisamente la gravedad. Cuanto más fuerte tira, más rápido oscila.

El periodo (T) es el tiempo que tarda en hacer una oscilación completa: ir hasta un extremo, hasta el otro y volver al punto de partida. Para oscilaciones pequeñas, el periodo depende solo de la longitud L del péndulo y de g:

T = 2\pi \sqrt{\frac{L}{g}}

Si despejamos g, tenemos la fórmula que usa el programa:

g = \frac{4\pi^{2} L}{T^{2}}

Fijaos en dos cosas curiosas. El peso del péndulo no aparece: una bola de plomo y una pluma atada al mismo hilo oscilarían igual (si no hubiera aire). Y la amplitud tampoco aparece, siempre que sea pequeña, unos 15 grados o menos.

¿Cómo mide el tiempo el Arduino?

Un giroscopio mide a qué velocidad gira algo, en grados por segundo. Cuando el péndulo se mueve hacia un lado, el sensor gira en un sentido; cuando vuelve, gira en el contrario. En cada extremo del recorrido se detiene un instante y cambia de sentido.

Ese instante es nuestro cronómetro: la velocidad de giro pasa de negativa a positiva y cruza el cero. El Arduino detecta el cruce, apunta la hora, y el tiempo entre dos cruces seguidos de la misma clase es un periodo.

¿Cómo conseguimos precisión?

El Arduino mide el giro 100 veces por segundo, una cada 10 milisegundos. Si el cruce por cero cae entre dos medidas, el programa calcula dónde estaría exactamente con una regla de tres (interpolación). Así la precisión del tiempo es mucho mejor que esos 10 ms.

También usamos un umbral: solo contamos un cruce si antes el péndulo ha girado claramente hacia atrás (más de 8 grados por segundo). Así el ruido del sensor, que siempre baila un poquito alrededor del cero, no cuenta como oscilación.

¿Y si el sensor está un poco descalibrado?

Un giroscopio quieto debería marcar cero, pero siempre marca un poco, lo que se llama sesgo. Al arrancar, el programa mide el sensor durante dos segundos con todo quieto y resta ese valor. Por eso, al encender, no hay que tocar el péndulo.

Qué necesitamos

• Un Arduino Mega 2560 con su cable USB.
• Un sensor MPU-6050 (en la placa HW-123 o GY-521) con sus patillas soldadas.
• Cuatro cables de puente (jumpers) hembra-macho o macho-macho, según tu placa.
• Hilo o cuerda, y algo de donde colgarlo: el borde de una mesa, una puerta o un soporte de laboratorio.
• Cinta adhesiva y una regla o cinta métrica.

Conexiones

Son las mismas del chisme 50. Conecta con el Arduino desenchufado del USB:

MPU-6050	Arduino Mega
VCC	3.3V
GND	GND
SDA	pin 20
SCL	pin 21

En el Mega, los pines 20 y 21 son los de comunicación I2C, el idioma con el que el Arduino habla con el sensor.

Montaje del péndulo

1. Pega el sensor con cinta al extremo de una regla o de un cartón rígido, con las patillas hacia fuera y los cables sueltos, para que no tiren.
2. Cuelga esa regla de un clavo o del borde de una mesa de modo que pueda girar libremente, como un péndulo. El punto de giro debe quedar fijo.
3. Mide con la regla la longitud L: la distancia desde el punto de giro hasta el sensor, en metros. Por ejemplo, 0,50 m.
4. Deja el Arduino sobre la mesa, con cables suficientemente largos y flojos para que no frenen el movimiento.

Cuanto más rígido sea el péndulo y más fijo el punto de giro, mejores medidas obtendrás. Un hilo con una bola colgada funciona también, si pegas bien el sensor a la bola.

El código del Arduino

En el IDE de Arduino: Archivo → Nuevo, pega el código y guárdalo con el nombre chisme52_pendulo_mega. Placa: Arduino Mega or Mega 2560.

El programa tiene dos modos. Con MODO_GRAFICA = true dibuja el giro de los tres ejes en el Serial Plotter, para averiguar cuál es el eje de tu péndulo. Con false mide los periodos y calcula g. Solo hay que cambiar las cuatro constantes del apartado “LO QUE TIENES QUE CAMBIAR”.

Lo importante está en la función buscarPeriodo(): detecta el cruce por cero, calcula el periodo y la gravedad.

// Chisme 52 - El péndulo del Lince (parte 1: el Arduino Mega)
// Mide cuánto tarda en oscilar un péndulo con el giroscopio del MPU-6050 y calcula la gravedad.
//
// CONEXIONES (las mismas del chisme 50):
//   MPU-6050 VCC -> 3.3V     GND -> GND
//   SDA -> pin 20            SCL -> pin 21
//
// CÓMO SE USA (dos pasos):
//   PASO 1 (MODO_GRAFICA = true): sube el programa, abre Herramientas > Serial Plotter (115200)
//          y balancea el péndulo. Verás tres líneas (gx, gy, gz): la que oscila mucho es el
//          eje de giro de tu péndulo. Apunta su número en EJE (0 = x, 1 = y, 2 = z).
//   PASO 2 (MODO_GRAFICA = false): mide la LONGITUD_M, ponla abajo, sube el programa y abre
//          el Monitor Serie (115200). Cada oscilación escribe su periodo y la gravedad.
//
// LA FÍSICA: un péndulo pequeño oscila con periodo  T = 2 * pi * raiz(L / g)
//            Despejando:  g = 4 * pi^2 * L / T^2

#include <Wire.h>

const uint8_t MPU = 0x68;                 // dirección del MPU-6050

// ===== LO QUE TIENES QUE CAMBIAR =====
const bool  MODO_GRAFICA = true;          // true = paso 1 (dibujar), false = paso 2 (medir)
const int   EJE = 0;                      // eje del giroscopio que oscila: 0 = x, 1 = y, 2 = z
const float LONGITUD_M = 0.50;            // distancia del punto de giro hasta el sensor, en metros
const float UMBRAL = 8.0;                 // grados/s: el péndulo tiene que girar al menos así de rápido

const float CUENTAS_POR_GPS = 131.0;      // giroscopio en +-250 grados/s: 131 cuentas por grado/s
const unsigned long CADA_US = 10000;      // una medida cada 10 ms = 100 por segundo

float sesgo[3] = {0, 0, 0};               // lo que marca el giroscopio quieto (se resta)
unsigned long siguiente;                  // momento de la siguiente medida (microsegundos)

// Para medir el periodo
float vAntes = 0;                         // velocidad de giro de la medida anterior
unsigned long tAntes = 0;                 // momento de la medida anterior
bool armado = false;                      // true cuando el péndulo ya ha girado "hacia atrás"
unsigned long ultimoCruceUs = 0;          // momento del último cruce por cero
bool hayCruce = false;
float ultimos[5];                         // los últimos 5 periodos
int nPeriodos = 0;                        // cuántos periodos llevamos
int numOscilacion = 0;


// Pide 14 bytes al sensor y los convierte en 7 números: aceleración x,y,z, temperatura, giro x,y,z
bool leerCrudo(int16_t *v) {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);
  if (Wire.endTransmission(false) != 0) return false;
  if (Wire.requestFrom((int)MPU, 14) != 14) return false;
  for (int i = 0; i < 7; i++) {
    int16_t alto = Wire.read();
    int16_t bajo = Wire.read();
    v[i] = (alto << 8) | bajo;
  }
  return true;
}


void escribirRegistro(uint8_t registro, uint8_t valor) {
  Wire.beginTransmission(MPU);
  Wire.write(registro);
  Wire.write(valor);
  Wire.endTransmission();
}


void setup() {
  Serial.begin(115200);
  Wire.begin();
  escribirRegistro(0x6B, 0x00);           // despertamos el sensor
  escribirRegistro(0x1A, 0x03);           // filtro interno de ~44 Hz

  Serial.println("# Calibrando el giroscopio: NO muevas el péndulo (2 segundos)");
  delay(500);
  long suma[3] = {0, 0, 0};
  int buenas = 0;
  int16_t v[7];
  for (int i = 0; i < 200; i++) {
    if (leerCrudo(v)) {
      for (int k = 0; k < 3; k++) suma[k] += v[4 + k];
      buenas++;
    }
    delay(5);
  }
  if (buenas == 0) {
    Serial.println("# ERROR: el MPU-6050 no responde. Revisa el cableado.");
    while (true) { }
  }
  for (int k = 0; k < 3; k++) sesgo[k] = suma[k] / (float)buenas / CUENTAS_POR_GPS;
  Serial.println(MODO_GRAFICA ? "# Listo: balancea el pendulo y mira el Serial Plotter"
                              : "# Listo: balancea el pendulo (que no pase de unos 15 grados)");
  siguiente = micros();
}


// Se llama con cada medida del eje elegido (grados/s). Busca el momento en que la velocidad pasa
// de negativa a positiva: el péndulo está en un extremo y empieza a volver.
void buscarPeriodo(float v, unsigned long t) {
  if (v < -UMBRAL) armado = true;                      // ha girado claramente hacia atrás
  if (armado && vAntes < 0 && v >= 0) {                // cruce por cero hacia arriba
    // Posición exacta del cruce entre las dos medidas (interpolación)
    float fraccion = (0 - vAntes) / (v - vAntes);
    unsigned long cruce = tAntes + (unsigned long)(fraccion * (t - tAntes));
    armado = false;
    if (hayCruce) {
      float T = (cruce - ultimoCruceUs) / 1000000.0;   // periodo en segundos
      if (T > 0.3 && T < 4.0) {                        // descartamos cosas absurdas (ruido)
        numOscilacion++;
        ultimos[nPeriodos % 5] = T;
        nPeriodos++;
        int cuantos = nPeriodos < 5 ? nPeriodos : 5;
        float media = 0;
        for (int i = 0; i < cuantos; i++) media += ultimos[i];
        media /= cuantos;
        float g = 4.0 * PI * PI * LONGITUD_M / (media * media);
        Serial.print("Oscilacion ");  Serial.print(numOscilacion);
        Serial.print(": T = ");       Serial.print(T, 3);
        Serial.print(" s | media = "); Serial.print(media, 3);
        Serial.print(" s | g = ");     Serial.print(g, 2);
        Serial.println(" m/s2");
      }
    }
    ultimoCruceUs = cruce;
    hayCruce = true;
  }
  vAntes = v;
  tAntes = t;
}


void loop() {
  if ((long)(micros() - siguiente) < 0) return;        // todavía no toca medir
  siguiente += CADA_US;

  int16_t v[7];
  unsigned long t = micros();
  if (!leerCrudo(v)) return;
  float g3[3];
  for (int k = 0; k < 3; k++) g3[k] = v[4 + k] / CUENTAS_POR_GPS - sesgo[k];

  if (MODO_GRAFICA) {
    Serial.print("gx:"); Serial.print(g3[0], 1); Serial.print(',');
    Serial.print("gy:"); Serial.print(g3[1], 1); Serial.print(',');
    Serial.print("gz:"); Serial.println(g3[2], 1);
  } else {
    buscarPeriodo(g3[EJE], t);
  }
}

Lee y predice. Si cuadruplicas la longitud del hilo, ¿cuánto cambia el periodo? Pista: en la fórmula, L está dentro de una raíz cuadrada. Compruébalo con una regla de 0,25 m y otra de 1 m.

Cómo probarlo

Paso 1: averiguar el eje

1. Deja MODO_GRAFICA = true (viene así). Sube el programa al Mega con el péndulo quieto: los primeros 2 segundos calibra el giroscopio.
2. Abre Herramientas → Serial Plotter, a 115200 baudios.
3. Balancea el péndulo con una amplitud pequeña. Verás tres líneas, gx, gy y gz.
4. La que dibuja una onda grande y regular es el eje de giro de tu péndulo. Apunta su número en EJE: 0 si es gx, 1 si es gy y 2 si es gz.

Si las tres líneas casi no se mueven, el péndulo gira demasiado despacio o con poca amplitud. Prueba con un balanceo un poco mayor (sin pasar de unos 15 grados).

Paso 2: medir g

1. Cambia MODO_GRAFICA a false.
2. Escribe en LONGITUD_M la longitud que mediste, en metros.
3. Sube el programa. De nuevo, péndulo quieto mientras calibra.
4. Abre el Monitor Serie a 115200 y balancea el péndulo.
5. Cada oscilación aparece una línea como esta:

Oscilacion 3: T = 1.419 s | media = 1.419 s | g = 9.81 m/s2

Aparecen el periodo de esa oscilación (T), la media de las últimas cinco y la g calculada con esa media. Fijáte en que las primeras líneas, con menos de cinco periodos, promedian menos datos y fluctúan más.

Con un péndulo de 0,50 m, el periodo esperado es de unos 1,42 s. Si el tuyo es muy distinto, comprueba la longitud medida y el eje elegido.

Qué estamos midiendo realmente

La Gata hace la pregunta: —¿Y si te sale 10,3 en vez de 9,8, es que la gravedad de Sierra Bermeja es distinta?

Lo más probable es que no. Lo que el Arduino mide es un tiempo; la longitud la medimos nosotros con una regla; y g sale de combinar las dos con una fórmula que da por supuestas varias cosas. Cualquier error en esas cosas acaba en el resultado.

La g depende de la longitud (en proporción directa) y del periodo (al cuadrado, en el denominador). Por eso un error del 1 % en el periodo da un 2 % de error en g.

Fuente de error	Cómo afecta a g
La longitud está mal medida (1 cm de error en 50 cm)	Un 2 % de error en g
La amplitud es grande (30° en lugar de 15°)	El periodo sale un 1,7 % más largo que el ideal y g sale más baja
El péndulo no es un punto colgado de un hilo (por ejemplo, una regla)	La longitud correcta no es hasta el sensor: el error puede ser de varios por ciento
El punto de giro se mueve o roza	El periodo cambia de forma irregular
El sensor mide cada 10 ms	Se compensa con la interpolación, pero aún hay un pequeño error

Una diferencia importante: promediar varias oscilaciones reduce el error aleatorio (el que cambia de una a otra), pero no el sistemático (el que se repite siempre, como una longitud mal medida). Si todas las medidas salen 5 % altas, medir más veces no lo arregla.

Además, g no vale lo mismo en todo el planeta: ronda 9,78 m/s² en el ecuador y 9,83 m/s² en los polos, y baja un poco con la altura. En el sur de España ronda 9,80, pero con un péndulo de pasillo y una regla es muy difícil distinguir esas diferencias. Un resultado entre 9,5 y 10,1 es, en la práctica, un buen resultado.

Para el aula

Este es un experimento ideal para el laboratorio de Física. Algunas actividades:

• Predecir antes de medir. Con L = 0,50 m, ¿cuánto debería valer T? Calcúlalo con la fórmula y compara con el Arduino.
• Variable y unidad. ¿Qué mide el Arduino realmente: un tiempo, una velocidad de giro o una aceleración? ¿En qué unidades?
• Cambiar una sola cosa. Repite con tres longitudes (0,25, 0,50 y 1,00 m), sin tocar nada más. ¿Se cumple que T crece con la raíz de L?
• Masa y amplitud. ¿Cambia el periodo si añades peso al péndulo? ¿Y si lo sueltas desde más alto? Diseña la prueba y escribe tu hipótesis antes de hacerla.
• Comparar grupos. Cada grupo mide g con su péndulo. ¿Coinciden? Si no, ¿cuál es la causa más probable?
• Error aleatorio y sistemático. ¿Cuántas oscilaciones hay que promediar para que el resultado deje de bailar? ¿Por qué no basta con medir más veces si la regla estaba mal?
• Dato y medida. Un periodo de 1,419 s, ¿cuántas cifras decimales merecen creerse? Justifícalo con lo que hemos visto de errores.

Retos

1. Haz que funcione. Monta el péndulo, encuentra el eje y consigue ver tu primera g en el Monitor Serie.
2. Modifica algo. Cambia UMBRAL a 3 y a 20. ¿Qué ocurre con el número de oscilaciones que detecta? ¿Por qué?
3. Añade un cálculo. Haz que el programa muestre también la frecuencia (1 / T) de cada oscilación.
4. Guarda los datos. Copia las líneas del Monitor Serie a una hoja de cálculo, con una columna para T y otra para g.
5. Representa los datos. Haz una gráfica de g frente al número de oscilación. ¿Se estabiliza?
6. Automatiza. Haz que el programa calcule la media y la desviación típica de las 20 primeras oscilaciones y las escriba al final.
7. Haz que otro dispositivo participe. Pasa los periodos al móvil con el puente de los chismes 50 y 51 y dibuja ahí la gráfica en directo.
8. Conviértelo en investigación. Mide g con péndulos de cinco longitudes distintas y representa T² frente a L. Si los puntos forman una recta, su pendiente vale 4π²/g. ¿Qué g sale de ahí? ¿Es mejor que la de una sola medida?

Qué hemos aprendido

Hemos calculado la gravedad con Arduino usando un péndulo y un giroscopio. El sensor nos da el instante en que el péndulo cambia de sentido, el Arduino mide el tiempo entre dos cambios iguales, y una fórmula convierte ese periodo y la longitud del hilo en g.

Hemos visto que un resultado no es bueno o malo por sí solo: depende de los errores que lo rodean. Una regla mal usada o una amplitud grande pesan más que cualquier sensor.

El Lince colgó el péndulo de una rama, leyó el número en la pantalla y miró a la Gata.

—Nueve con ochenta y dos. Es casi la gravedad de los libros.

—Casi. Y ahora ya sabes por qué casi.

—Aun así, la piedra era más divertida.

—Ya lo sé —dijo ella, y le quitó la piedra de la pata.

Para seguir investigando

• Otros usos de este sensor: en el nivel de burbuja el acelerómetro dice hacia dónde está inclinada la placa.
• Una señal que oscila: el sismógrafo de la mano dibuja temblores a lo largo del tiempo.
• Medir y guardar datos del entorno: la estación del tiempo con micro:bit.
• Fuentes externas: qué es un péndulo y cómo funciona un giroscopio, en Wikipedia.

Si te interesa la idea de medir con un sensor durante horas, el siguiente paso es un sismógrafo de Sierra Bermeja.