¿Te acuerdas haber leído acerca de las leyes del movimiento de Newton un par de secciones atrás? Estamos casi listos para convertir esas leyes en código que pueda ejecutarse. Después de todo, ha sido agradable aprender acerca de triángulos y tangentes y ondas, pero en realidad, la esencia de este curso es acerca de simular la física de los cuerpos en movimiento. Echemos un vistazo a cómo la trigonometría nos puede ayudar con esta búsqueda.
Diagrama del péndulo con ángulos
Un péndulo es una masa suspendida de un pivote. Obviamente un péndulo en el mundo real viviría en un espacio tridimensional, pero vamos a ver un escenario más simple, un péndulo en un espacio 2D: la pantalla del programa.
En la sección de Fuerzas, aprendimos cómo una fuerza (como la fuerza de gravedad mostrada en el diagrama anterior) provoca que un objeto se acelere. **F = M * A** o **A = F / M**. En este caso, sin embargo, la masa del péndulo simplemente no cae al suelo porque está conectada por un brazo hasta el punto de pivote. Y así, para poder determinar su aceleración angular, no solo necesitamos mirar la fuerza de gravedad, sino también la fuerza en el ángulo del brazo del péndulo (relativa a un péndulo en reposo con un ángulo de 0).
En el caso anterior, como el brazo del péndulo tiene una longitud fija, la única variable en el escenario es el ángulo. Vamos a simular el movimiento del péndulo mediante el uso de la velocidad angular y la aceleración. La aceleración angular se calculará utilizando la segunda ley de Newton con un pequeño toque de trigonometría.
Vamos a acercarnos al triángulo rectángulo del diagrama del péndulo.
Podemos ver que la fuerza del péndulo (F, start subscript, p, end subscript) debe apuntar de manera perpendicular al brazo del péndulo en la dirección que el péndulo está oscilando. Después de todo, si no hubiera ningún brazo, la masa caería hacia abajo. La fuerza de tensión del brazo es la que mantiene a la masa acelerándose hacia el estado de reposo del péndulo. Puesto que la fuerza de gravedad (F, start subscript, g, end subscript) apunta hacia abajo, al hacer un triángulo rectángulo a partir de estos dos vectores, logramos algo bastante magnífico. Hicimos a la fuerza de gravedad la hipotenusa de un triángulo rectángulo y separamos el vector en dos componentes, uno de los cuales representa la fuerza del péndulo. Como el seno es igual al cateto opuesto sobre la hipotenusa, tenemos:
s, e, n, o, left parenthesis, theta, right parenthesis, equals, start fraction, F, start subscript, p, end subscript, divided by, F, start subscript, g, end subscript, end fraction
Por lo tanto:
F, start subscript, p, end subscript, equals, F, start subscript, g, end subscript, times, s, e, n, o, left parenthesis, theta, right parenthesis
No lo olvidemos, hemos estado haciendo todo esto con una sola pregunta en mente: ¿cuál es la aceleración angular del péndulo? Una vez que tengamos la aceleración angular, seremos capaces de aplicar nuestras reglas de movimiento para encontrar el nuevo ángulo para el péndulo.
velocidad angular = velocidad angular + aceleración angular
ángulo = ángulo + velocidad angular
La buena noticia es que con la segunda ley de Newton, sabemos que existe una relación entre la fuerza y la aceleración, es decir F, equals, M, times, A, o A, equals, F, slash, M, y podemos usar esa relación con la fórmula anterior para averiguar la aceleración angular. Ve si puedes seguir esto:
Empezando con:
fuerza del péndulo = fuerza debida a la gravedad * seno(θ)
Luego dividimos el lado derecho entre la masa, para obtener la aceleración, con base en la segunda ley de Newton:
aceleración angular del péndulo = (fuerza debida a la gravedad * seno(θ)) / masa
Luego nos damos cuenta de que simplemente podemos dividir la fuerza debida a la gravedad entre la masa y que eso es lo mismo que la aceleración debida a la gravedad, así que simplemente sustituimos eso:
aceleración angular del péndulo = aceleración debida a la gravedad * seno (θ)
¡Ta-rán! Ahora tenemos una manera de calcular la aceleración angular.
Este es un buen momento para recordarnos a nosotros mismos que somos programadores de ProcessingJS y no físicos. Sí, sabemos que la aceleración debida a la gravedad en la Tierra es de 9.8 metros por segundo cuadrado. Pero este número no es relevante para nosotros. Lo que tenemos aquí es una constante arbitraria (que llamaremos gravedad), una que podemos utilizar para escalar la aceleración a algo que se sienta bien.
aceleración angular = gravedad * seno(θ)
Increíble. Después de todo eso, la fórmula es tan simple. Podrías estarte preguntando, ¿por qué molestarnos en pasar por toda la derivación? Es decir, aprender es genial y todo, pero podríamos fácilmente haber dicho, "Oye, la aceleración angular de un péndulo es una constante por el seno del ángulo". Este es solo otro momento en el que nos recordamos a nosotros mismos que el propósito del curso no es aprender cómo oscilan los péndulos o cómo funciona la gravedad. El punto es pensar creativamente acerca de cómo las cosas pueden moverse sobre la pantalla en un sistema de gráficos basado en computadora. El péndulo es solo un caso de estudio. Si puedes entender la manera de abordar la programación de un péndulo, entonces sin importar cómo decidas diseñar tu mundo en la pantalla, puedes aplicar las mismas técnicas.
Por supuesto, no hemos terminado todavía. Podremos estar contentos con nuestra fórmula simple y elegante, pero aún tenemos que aplicarla en el código. Este es definitivamente un buen momento para practicar nuestras habilidades de programación orientada a objetos y crear un objeto Pendulum (péndulo). Vamos a pensar en todas las propiedades que hemos encontrado en nuestra discusión sobre el péndulo que el objeto tendrá que hacerles un seguimiento:
  • longitud del brazo
  • ángulo
  • velocidad angular
  • aceleración angular
Además también vamos a querer especificar de dónde está colgando el péndulo, así que podríamos empezar con un constructor como este:
var Pendulum  = function(origin, armLength) {
    this.origin = origin;
    this.armLength = armLength;

    this.angle = PI/4;
    this.aVelocity = 0.0;
    this.aAcceleration = 0.0;
};
También tendremos que escribir un método update() para actualizar el ángulo del péndulo de acuerdo con nuestra fórmula…
Pendulum.prototype.update = function() {
    // Constante arbitraria
    var gravity = 0.4;
    // Calcular la aceleración
    this.aAcceleration = -1 * gravity * sin(this.angle);
    // Aumentar la velocidad
    this.aVelocity += this.aAcceleration;
    // Aumentar el ángulo
    this.angle += this.aVelocity;    
};
…así como un método display() para dibujar el péndulo en la ventana. Esto plantea la pregunta: “Mmh, ¿dónde dibujamos el péndulo?” Conocemos el ángulo y la longitud del brazo, pero ¿cómo podemos saber las coordenadas (¡cartesianas!) x, y para el punto de pivote (llamémoslo origen) y para la ubicación de la masa (llamémosla posición)? Esto puede empezar a ser un poco agotador, pero ,una vez más, la respuesta es trigonometría. Vamos a hacer referencia al diagrama de la izquierda.
El origen simplemente es algo que inventamos, al igual que la longitud del brazo. Digamos que construimos nuestro péndulo así:
var p = new Pendulum(new PVector(100, 10), 125);
Estamos almacenando el ángulo actual en la propiedad angle. Así que relativa al origen, la posición del péndulo es una coordenada polar: (r, angle). Y necesitamos que sea cartesiana. Afortunadamente para nosotros, pasamos algún tiempo en la sección de Ángulos derivando la fórmula para convertir de polares a cartesianas. En esa sección, nuestro ángulo era relativo al eje horizontal, pero aquí, es relativo al eje vertical, así que terminamos usando sin() para la posición x y cos() para la posición y, en lugar de cos() y sin(), respectivamente. Y así, podemos calcular la posición relativa al origen mediante esa fórmula de conversión y luego agregarle la posición del origen:
this.position = new PVector(
   this.armLength * sin(this.angle),
   this.armLength * cos(this.angle));
this.position.add(this.origin);
stroke(0, 0, 0);
fill(175, 175, 175);
line(this.origin.x, this.origin.y, this.position.x, this.position.y);
ellipse(this.position.x, this.position.y, 16, 16);
Antes de que juntemos todo, hay un último detalle pequeño que omití mencionar. Pensemos acerca del brazo del péndulo por un momento. ¿Es una barra de metal? ¿Una cuerda? ¿Una liga? ¿Cómo está unida al punto de pivote? ¿Qué tan larga es? ¿Cuál es su masa? ¿Es un día de viento? Hay muchas preguntas que podríamos seguir haciendo que afectarían a la simulación. Estamos viviendo, por supuesto, en un mundo de fantasía, uno donde el brazo del péndulo es un varilla idealizada que nunca se dobla y la masa del péndulo está concentrada en un solo punto, infinitesimalmente pequeño.
Sin embargo, aunque no queramos preocuparnos con todas las preguntas, deberíamos añadir una variable más a nuestro cálculo de aceleración angular. Para mantener las cosas sencillas, en nuestra derivación de la aceleración del péndulo, supusimos que la longitud del brazo del péndulo es 1. De hecho, la longitud del brazo del péndulo afecta en gran medida a la aceleración: mientras más largo sea el brazo, más lenta será la aceleración. Para simular un péndulo con mayor precisión, dividimos entre esa longitud, en este caso armLength. Para una explicación más elaborada, visita el sitio web del péndulo simple.
this.aAcceleration = (-1 * gravity / this.armLength) * sin(this.angle);
Por último, un péndulo en el mundo real va a experimentar cierta cantidad de fricción (en el punto de pivote) y resistencia del aire. Con nuestro código como está, el péndulo oscilaría para siempre, así que para hacerlo más realista podemos usar un truco de “amortiguamiento”. Digo truco porque en lugar de modelar las fuerzas de resistencia con algún grado de precisión (como lo hicimos en la sección de Fuerzas), podemos lograr un resultado similar simplemente reduciendo la velocidad angular durante cada ciclo. El siguiente código reduce la velocidad en un 1% (o la multiplica por 99%) durante cada cuadro de animación:
this.aVelocity *= this.damping;
Juntando todo, tenemos el siguiente ejemplo. Agregamos un poco de funcionalidad para facilitar arrastrar la masa y también para soltarla de diferentes alturas. ¡ Pruébalo!

Este curso de "Simulaciones Naturales" es un derivado de "La Naturaleza del Código" por Daniel Shiffman, usado bajo una Licencia Creative Commons Reconocimiento-NoComercial 3.0 Unported.