Contenido principal

Programación de computadoras

Curso: Programación de computadoras > Unidad 5

Lección 7: Oscilaciones

Trigonometría y fuerzas: el péndulo

¿Recuerdas las leyes de Newton del movimiento de unas secciones atrás? En aquel entonces, utilizamos esas leyes para calcular la aceleración de un objeto, de manera que podemos calcular y dibujar su nueva posición en el mundo. Ahora, vamos a utilizar esas leyes para calcular la aceleración de un péndulo, para calcular y dibujar su posición a lo largo de la oscilación. Y resulta que vamos a necesitar la ayuda de la trigonometría en el camino.

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 (tal como la fuerza de gravedad que se muestra en el diagrama anterior) provoca que un objeto se acelere: F, equals, M, times, A o A, equals, F, slash, M.

Sin embargo, en este caso, la masa del péndulo no solo cae el suelo, ya que está unida al punto de pivote por medio de un brazo. En lugar de eso, la masa oscila hacia su posición de reposo y queremos calcular la aceleración de la masa a lo largo de la oscilación. A eso lo llamamos su aceleración angular, ya que el péndulo está acelerando a lo largo de un arco.

Para determinar la aceleración angular del péndulo tenemos que descomponer la fuerza de gravedad en componentes. Una de las componentes será a lo largo del brazo del péndulo. Podemos ignorar esa componente porque el brazo siempre está jalando contra ella, cancelándola. La otra componente es perpendicular al brazo. Esa es la que nos importa porque está jalando el péndulo "lateralmente", haciéndolo oscilar. Vamos a ampliar el diagrama del péndulo y visualizar esas componentes de la fuerza de gravedad:

F, start subscript, g, end subscript es la fuerza total de la gravedad que apunta hacia abajo. F, start subscript, p, end subscript es la fuerza de gravedad perpendicular al brazo del péndulo, que apunta en la dirección opuesta a la que el péndulo oscila. F, start subscript, a, end subscript es la fuerza de la gravedad a lo largo del brazo, la cual vamos a ignorar ya que no va a afectar a la aceleración angular.

Ahora ¿cómo calculamos F, start subscript, p, end subscript? Aquí es donde utilizamos la trigonometría. F, start subscript, g, end subscript es la hipotenusa de un triángulo rectángulo y theta es el ángulo del brazo. El seno es igual al cateto opuesto sobre la hipotenusa:

sine, 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, dot, sine, left parenthesis, theta, right parenthesis

Muy bien, ahora tenemos una fórmula sencilla para calcular F, start subscript, p, end subscript. Ahora regresemos a nuestra pregunta original: ¿cuál es la aceleración angular del péndulo? Una vez que encontremos la aceleración angular, podremos aplicar nuestras reglas del movimiento para encontrar el nuevo ángulo del péndulo.

velocidad angular = velocidad angular + aceleración angular
ángulo = ángulo + velocidad angular

Gracias a 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 calcular una aceleración angular. Ve si puedes seguir esto:

Empezando con:
fuerza perpendicular = 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 = (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 = aceleración debida a la gravedad * seno (θ)

¡Ta-rán! Ahora tenemos una manera de calcular la aceleración angular.

Podemos simplificar eso todavía más, ya que somos programadores de ProcessingJS y no físicos. Sí, sabemos que la aceleración debida a gravedad en la Tierra es de 9.8 metros por segundo cuadrado. Pero este número no es relevante para nosotros. En nuestros programas, nuestra "gravedad" solo es un número arbitrario, uno que podemos utilizar para aumentar la escala de la aceleración a algo que se sienta que es correcto.

aceleración angular = gravedad * seno(θ)

Impresionante. Después de todo lo anterior, la fórmula es tan sencilla. Tal vez te estés preguntando, ¿por qué molestarse en hacer toda la derivación? Es decir, aprender es genial y todo, pero fácilmente podríamos haber dicho: "Oye, la aceleración angular de un péndulo es una constante multiplicada por el seno del ángulo".

Este es solo otro momento en el que recordamos que el objetivo del curso no es aprender cómo oscilan los péndulos o cómo funciona la gravedad. Se trata de pensar de manera creativa acerca de cómo se pueden mover cosas en la pantalla en un sistema de gráficas basado en computadora. El péndulo es solamente un estudio de caso. Si puedes entender el enfoque para programar un péndulo, entonces sin importar cómo escojas 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.

¿Quieres unirte a la conversación?

Inicia sesión

Ordenar por:

Sin publicaciones aún.

¿Sabes inglés? Haz clic aquí para ver más discusiones en el sitio en inglés de Khan Academy.