Retroinformática - Cómo aplicar e implementar algoritmos de físicas en ordenadores retro (2º Parte) - Movimiento rectilineo uniformemente acelerado con Amos Basic

     En esta ocasión vamos a explicar que es el Movimiento Rectilineo Uniforme Acelerado y como aplicarlo a un algoritmo en el lenguaje Basic. Concretamente en el lenguaje Amos Basic para ordenadores Amiga.

   

     En el capítulo anterior vimos que es la velocidad rectilínea uniforme y como ésta se mantiene constante a lo largo del tiempo. Es decir, si el objeto empieza a moverse con una velocidad instantánea de 10 píxeles por segundo seguirá a esa misma velocidad todo el tiempo que se esté moviendo. 

      En cambio, en el movimiento rectilíneo uniforme acelerado, su aceleración es constante a lo largo del tiempo, y esto quiere decir que su velocidad instantánea va cambiando a lo largo del tiempo.  Por ejemplo, si decimos que un objeto tiene una aceleración de 10 metros por segundo al cuadrado, esto quiere decir que cada segundo habrá aumentado su velocidad instantánea en 10 metros por segundo. Es decir, si el objeto parte de velocidad 0, irá aumentando poco a poco su velocidad y cuando llegue al primer segundo de tiempo, su velocidad ya será de 10 metros por segundo. Entre el tiempo que pasa entre el segundo 1 y el segundo 2, su velocidad ya habrá aumentado a 20 metros por segundo, y así consecutivamente. En el siguiente esquema se aprecia mejor:

   

  0 -------------- 1 ---------------- 2 ----------------3 ----------------4-----------------5

 0m/s            10m/s             20m/s           30m/s           40m/s             50m/s

   
 
   Estos incrementos de tiempo y velocidades se puede expresar analíticamente como:

   

      Aquí, el problema fundamental para implementar está física en un programa de ordenador, es controlar como la velocidad se tiene que ir incrementando poco a poco de un segundo a otro. Lo primero que hay que hacer, al igual que pasaba en el primer artículo de esta serie, es saber cual es el incremento de pixels por cada 0.02 segundos(tic de reloj cada 20 milisegundos). Es decir, si decimos que un objeto se mueve con una aceleración de 10 pixeles por segundo, pasemos esto a pixeles por cada tic de reloj (20 milisegundos). Utilizaremos una sencilla regla de 3.

         10 pixeles  ------------------> 1000 ms (milisegundos)
               a         -------------------> 20 ms  

   a = (20 * 10) / 1000 = 0.2 píxeles por cada tic de reloj.

   Esto quiere decir que la velocidad en cada tic de reloj, aumentará 0.2 píxeles.

Por tanto, si partimos de que el objeto empieza con velocidad 0, a los 20 milisegundos, ya tendrá una velocidad de 0.2 pixeles/seg, a los 40 milisegundos, tendrá un velocidad de 0.4 pixeles/seg, a los 60 milisegundos tendrá una velocidad de 0.6 pixeles/seg, a los 80 milisegundos tendrá una velocidad de 0.8 pixeles/seg  y a los 100 milisegundos tendrá una velocidad de 1 pixel/seg.

   Entonces, a los 1000 milisegundos(1 segundo), tendremos los 10 pixeles por segundo. Y así sucesivamente.

    Como vemos, el incremento de 0.2 pixeles por cada tic de reloj, que es la aceleración del objeto, habrá que sumárselo a la velocidad que se lleve en cada tic de reloj.  La función que hemos implementado también permite indicar la velocidad inicial del objeto, que no tiene porque ser 0. Y la tenemos que indicar en pixeles por segundo. Por tanto, también la convertimos a pixeles por cada tic de reloj (20 milisegundos). Si suponemos una velocidad inicial de 20 pixels/seg:

     20 píxeles  -------------------------------> 1000 ms
        x             ------------------------------->  20 ms


     v = 0.4 pixels  por cada tic (20 ms)

   En nuestro caso de ejemplo de código, la velocidad inicial será de 0 pixeles/seg, pero la puedes modificar, al igual que la aceleración. El código te lo puedes bajar desde aquí.

   También debajo tienes el video donde se ve la ejecución del ejemplo. Lo que vais a ver son dos estrellas. La primera se mueve con la velocidad uniforme rectilinea de 50 pixeles por segundo, y el segundo objeto, se mueve con una aceleración de 20 pixeles por segundo al cuadrado, partiendo de velocidad inicial 0.

    Fijaos que el segundo objeto una vez llega a la derecha, vuelve hacia la izquierda deshacelerando. Para esto simplemente hay que pasar el valor de la aceleración en negativo.