Calculando el valor de ‘g’ con Arduino

g es el valor de la gravedad sobre la superficie terrestre, que vale 9,81 m/s2. ¿Y por
qué alguien iba a querer calcular un valor que está bien establecido? La respuesta es
sencilla: para mostrar una de las muchas posibilidades que ofrece arduino.

La idea
Los trabajos de Galileo dieron origen a la cinemática, el estudio de cuerpos en
movimiento. Cuando fuimos al instituto (o a la ESO los de menos años que yo) nos
enseñaron la relación que había entre el espacio recorrido por un cuerpo que cae y el
tiempo que tarda en llegar al suelo.
Cuando un cuerpo cae en la Tierra, el espacio que recorre es S = ½ x g x t2 (con
velocidad inicial nula) donde:
– S es el espacio recorrido en m

– g es la aceleración de la gravedad, nuestra protagonista y vale 9,81 m/s2

– t es el tiempo que tarda en caer en segundos

El valor de g varía ligeramente según el punto de la Tierra donde se mida.

La fórmula dice al menos dos cosas interesantes:
1ª El tiempo que tarda en caer un cuerpo no depende de su masa, es decir si dejo
caer una bola de 2 gramos y a la vez suelto un elefante de varios cientos de kilos
desde la misma altura, llegarán los dos a la vez a tierra
2º Si tengo el espacio que recorre y el tiempo que ha tardado en llegar, podría verificar
si g tiene el valor que nos han contado, sin más que despejar en la fórmula: g = 2 x S
/ t2
En el segundo punto nos vamos a basar para desarrollar un circuito que permita
calcular el valor de g a partir del espacio recorrido (conocido por la construcción del
experimento) y el tiempo que tarda en recorrerlo, cuyo valor obtendré con arduino,
que me permite medir milisegundos.

Preparación del circuito

Para medir g vamos a soltar una bola de hierro desde una cierta altura, en concreto 37
centímetros. Hay que pensar en algún mecanismo para que mida con precisión en
qué momento suelto la bola.
Para ello, utilicé la bobina de un relé después de desmontarlo para usarlo como
electroimán:
 Relé «ligeramente modificado» para hacer de electroimán

Nota: mi primera prueba la hice con un simple tornillo al que enrollé un cable aislado
(unas 40 vueltas). Funcionaba, pero la resistencia del cable era tan baja que
prácticamente estaba cortocircuitando las baterías. Puedes hacer la prueba, (con unas
baterías de repuesto a mano).

Alimenté la bobina a través de un relé que controlaría con arduino, con unas baterías
independientes del circuito de alimentación de arduino (se ven en el vídeo, abrí
la tapa de un aparato que tenía en casa). El circuito trabaja de la siguiente manera:
1- Nada más conectar arduino, la bobina queda energizada y el electroimán puede
sostener una bola de hierro. Ponemos el contador de tiempo de arduino en marcha
con la función millis().
2- Actúo sobre el pulsador (entrada digital). Arduino manda al relé cambiar (salida
digital) y desenergiza la bobina. Esta suelta la bola, que comienza a caer. A la vez,
tomamos nota del tiempo, t1 por ejemplo.
3- La bola llega a lo que podríamos llamar final de carrera improvisado: dos
«lengüetas» de papel de aluminio situadas próximas pero sin tocarse. Al llegar la bola,
se juntan y cierran un circuito que indica a arduino que la bola ha llegado (entrada
digital). Tomo nota del tiempo, t2 y enciendo un led (salida digital), enciendo el
led para saber, por una parte, que se ha producido bien el contacto y, por otra, para
verificar que el final de carrera, un tanto endeble, no queda cerrado (los dos contactos
unidos).
4- El contador de tiempo de arduino marca el tiempo que lleva la placa encendida
independientemente de lo que haga el programa, por tanto, el tiempo de caída es
t=t2-t1, que es el resultado. A partir de ahí calculo el valor de g y mando los dos
datos a una pantalla LCD (salidas digitales).
5- Espero un segundo. Apago el led. Cambio el relé para energizar la bobina y ya
puedo colocar la bola para repetir el experimento.
El diagrama de flujo del programa es muy sencillo:
Un experimento con arduino: obteniendo g

Se hacen todas las conexiones y se depura cualquier problema que pueda haber. El
esquema del conexionado se puede ver en la siguiente figura:
 Esquema de la realización del circuito

Al observar el circuito hay que tener en cuenta que el conexionado del relé que hace
caer la bola debe hacerse en función del componente que se utilice. Lo que se aprecia
es un esquema simplificado. No había en la librería de fritzing un relé similar al que
he usado.
Por otra parte he representado en el esquema como un pulsador el punto final de la
caída de la bola; es equivalente a las dos lengüetas de papel de aluminio que he
utilizado. No se puede usar físicamente el pulsador porque aparte de tener que
apuntar bien, la bola no tendría la fuerza suficiente para cerrar el circuito.
Algunas fotos del circuito final:

Imagen parcial de la placa de prototipos

 Módulo de relés utilizado para «soltar» la bola

Para los interesados, incluyo el código (sketch) que he escrito para el IDE (entorno de
programación) de arduino.

#include <LiquidCrystal.h>
LiquidCrystal lcd(9, 7, 5, 4, 3, 2);
unsigned long time;
unsigned long resultado;
unsigned long time1=0;
unsigned long time2=0;
int pul1=10;//entrada de activación pulsador
int fin_car2=11;//entrada de fin de caída los trozos de papel de aluminio
int rele=12;//para soltar la bola
int luz=13;//led que se activa al llegar la bola al final
int boton1=0;
int boton2=0;
float tiempo = 0;
float g;

void setup(){
pinMode(pul1,INPUT);
pinMode(fin_car2,INPUT);
pinMode(rele,OUTPUT);
pinMode(luz,OUTPUT);
Serial.begin(9600);
lcd.begin(16, 2);
lcd.print("Starting up.");//Inicializando
lcd.clear();
lcd.setCursor(0,0);
lcd.setCursor(0,1);
lcd.print("Started.");//Inicializado
}

void loop(){
time = millis();
boton1=digitalRead(pul1);

if(boton1==HIGH)
{
digitalWrite(rele, HIGH); //desmagnetizo la bobina
time1=time;//tomo el tiempo
}

boton2=digitalRead(fin_car2);
if(boton2==HIGH)
 {
time2=time;
resultado=time2-time1;
digitalWrite(luz,HIGH);

g=2*0.37/(resultado/1000.*resultado/1000.);//S=1/2gt2-> g=2xS/t2; bola a 37 cm

lcd.clear();
lcd.print("tiempo:");
lcd.print(resultado);
lcd.setCursor(0, 1);
lcd.print("g:");
lcd.print(g);
delay(1000);
digitalWrite(rele, LOW);//devolvemos el relé a su posición original
digitalWrite(luz, LOW);//apagamos el led
}
}

Sin embargo en algunas mediciones logré aproximarme al valor real, aunque la

variabilidad era muy significativa:

Imagen de una de las mediciones obtenidas

Como ya he indicado, la bola estaba aproximadamente a 37 cm, por lo que utilizando

la fórmula, el tiempo que debería tardar en recorrer esa distancia sería de 0,2746
segundos (274,6 milisegundos).
El experimento es preciso pulirlo (desde el punto de vista mecánico y de código para
tener en cuenta los distintos tiempos implicados en ciclos, caídas, etc.) hay que tener
en cuenta que estamos hablando de milisegundos y cualquier error o imprecisión
en el montaje puede dar lugar a resultados dispares.
El circuito sirve en todo caso para medir el tiempo entre un evento de partida y
otro de finalización, lo representa en pantalla y muestra las variables que nos
interesa.
La imaginación es el único límite para plantear este tipo de circuitos. La utilización de
sistemas como arduino sirve como método para la enseñanza de la programación de
los más jóvenes, que cuentan con el aliciente de ver los resultados del trabajo
casi de forma inmediata.