Trigonometria e forças: o pêndulo

Você se lembra de ter lido sobre as leis sobre movimento de Newton algumas sessões atrás? Estamos quase prontos para converter essas leis em código executável. Afinal, foi legal aprender sobre triângulos, tangentes e ondas, mas, na verdade, o objetivo desse curso é simular a física de corpos em movimento. Vamos dar uma olhada em como a trigonometria pode nos ajudar.

Um pêndulo é um prumo suspenso por um pivô. Obviamente, em um mundo real, um pêndulo estaria em um espaço 3D, mas iremos observar um cenário mais simples, um pêndulo em um espaço 2D—a tela do programa.

Na seção de forças, nós aprendemos como uma força (como a força da gravidade, mostrada no diagrama acima) faz com que um objeto acelere.**F = M * A** ou **A = F / M**. Nesse caso, no entanto, o prumo do pêndulo não pode simplesmente cair no chão porque ele é preso por um braço ao ponto pivô. Então, a fim de determinar a sua aceleração angular, não precisamos apenas olhar para a força da gravidade, mas também a força no ângulo do braço do pêndulo (em relação a um pêndulo em repouso com um ângulo de 0).

No caso acima, uma vez que o braço do pêndulo tem comprimento fixo, a única variável no cenário é o ângulo. Vamos simular o movimento do pêndulo através do uso da velocidade e aceleração angulares. A aceleração angular será calculada usando a segunda Lei de Newton com um pequeno toque de trigonometria.

Vamos ampliar o triângulo retângulo do diagrama do pêndulo.

Podemos ver que a força do pêndulo (

F_{p}

) deve apontar perpendicularmente ao braço do pêndulo na direção que ele está balançando. Afinal de contas, se não existissem braços, o prumo do pêndulo iria cair diretamente para baixo. É a força de tensão no braço que mantém o prumo acelerando em direção ao estado de repouso do pêndulo. Uma vez que a força gravidade (

F_{g}

) aponta para baixo, ao traçar um triângulo retângulo desses dois vetores, nós completamos algo magnífico. Fizemos da força gravidade a hipotenusa de um triângulo retângulo e separamos o vetor em dois componentes, um dos quais representa a força do pêndulo. Uma vez que o seno é igual ao ângulo oposto sobre a hipotenusa, nós temos:

s e n o (θ) = \frac{F_{p}}{F_{g}}

Portanto:

F_{p} = F_{g} \times s e n o (θ)

Não vamos esquecer, estamos fazendo tudo isso com uma pergunta em mente: qual é a aceleração angular do pêndulo? Quando temos a aceleração angular, seremos capazes de aplicar nossas regras do movimento para encontrar o novo ângulo para o pêndulo.

velocidade angular = velocidade angular + aceleração angular
ângulo = ângulo + velocidade angular

A boa notícia é que, com a segunda lei de Newton, sabemos que existe uma relação entre força e aceleração,

F = M \times A

, ou

A = F / M

, e podemos utilizar essa relação com a fórmula acima para descobrir a aceleração angular. Tente acompanhar:

Começando com:
força do pêndulo = força da gravidade * sen(θ)

Então dividimos o lado direito pela massa, para encontrar a aceleração, com base na segunda lei de Newton:
aceleração angular do pêndulo = (força da gravidade * sen(θ)) / massa

Então, percebemos que podemos simplesmente dividir a força da gravidade pela massa, e isso é o mesmo que a aceleração da gravidade, então vamos substituir isso:
aceleração angular do pêndulo = aceleração da gravidade * sen (θ)

Pronto! Agora temos uma forma de calcular a aceleração angular.

Esta é uma boa hora para lembrar-nos que somos programadores ProcessingJS e não físicos. Sim, nós sabemos que a aceleração da gravidade na terra é de 9,8 metros por segundo ao quadrado. Mas esse número não é relevante para nós. O que temos aqui é apenas uma constante arbitrária (vamos chamá-la de gravidade), que podemos usar para ajustar a aceleração para que ela pareça certa.

aceleração angular = gravidade * seno(θ)

Incrível. Depois de tudo isso, a fórmula é tão simples. Você deve estar se perguntando, por que se incomodar em deduzir tudo isso? Quer dizer, aprender é ótimo, mas poderíamos ter dito "Ei, a aceleração angular de um pêndulo é uma constante vezes o seno do ângulo." Este é apenas mais um momento em que devemos nos lembrar que o objetivo do curso não é aprender como pêndulos balançam ou como a gravidade funciona. A questão é pensar criativamente sobre como as coisas podem se mover na tela em um sistema gráfico feito através da computação. O pêndulo é apenas um estudo de caso. Se você consegue entender a abordagem para a programação de um pêndulo, quando for projetar um mundo na sua tela, você pode aplicar as mesmas técnicas.

Claro, ainda não acabamos. Podemos estar satisfeitos com a nossa fórmula simples e elegante, mas ainda temos que aplicá-la no código. Este é definitivamente um bom momento para praticar as nossas habilidades de programação orientada a objetos e criar um objeto Pendulum. Vamos pensar sobre todas as propriedades que encontramos em nossa discussão sobre o pêndulo que o objeto vai precisar acompanhar:

arm length - comprimento do braço
angle - ângulo
angular velocity - velocidade angular
angular acceleration - aceleração angular

Além disso, também queremos especificar onde o pêndulo está pendurado, então podemos começar com um construtor dessa forma:

var Pendulum  = function(origin, armLength) {
    this.origin = origin;
    this.armLength = armLength;

    this.angle = PI/4;
    this.aVelocity = 0.0;
    this.aAcceleration = 0.0;
};

Também precisamos escrever um método update() que atualize o ângulo do pêndulo de acordo com nossa fórmula…

Pendulum.prototype.update = function() {
    // Constante arbitrária
    var gravity = 0.4;
    // Calcular a aceleração
    this.aAcceleration = -1 * gravity * sin(this.angle);
    // Incrementar a velocidade
    this.aVelocity += this.aAcceleration;
    // Incrementar o ângulo
    this.angle += this.aVelocity;    
};

…bem como o método display() para desenhar o pêndulo na janela. Isso levanta a questão: “Onde desenhamos o pêndulo?” Sabemos o ângulo e o comprimento da corda, mas como descobrimos as coordenadas x,y (cartesianas!) para o pivô do pêndulo (vamos chamar de origem) e para a localização do prumo (vamos chamar de posição)? Isso pode estar ficando um pouco cansativo, mas a resposta é, novamente, trigonometria. Vamos tomar o diagrama à esquerda como referência.

A origem é algo que criamos, assim como o comprimento da corda. Vamos dizer que criamos um pêndulo assim:

var p = new Pendulum(new PVector(100, 10), 125);

Nós estamos armazenando o ângulo atual na propriedade angle. Então em relação à origem, a posição do pêndulo é uma coordenada polar: (r,ângulo). E precisamos que seja cartesiano. Felizmente, passamos algum tempo na seção de ângulos derivando a fórmula para conversão de polar para cartesiano. Naquela seção, nosso ângulo era em relação ao eixo horizontal, mas aqui é em relação ao eixo vertical, então utilizamos sin() para a posição x e cos() para a posição y, em vez de cos() e sin(), respectivamente. Então, podemos calcular a posição em relação à origem utilizando a fórmula de conversão e em seguida adicionando a posição de origem para ele:

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 colocarmos tudo junto, há um último detalhe que esqueci de mencionar. Vamos pensar sobre o braço do pêndulo por um momento. É uma haste de metal? Uma corda? Um elástico? Como ele é ligado ao ponto pivô? Qual o tamanho dele? Qual é a sua massa? É um dia com muito vento? Há diversas perguntas que poderíamos continuar a fazer que afetariam a simulação. Estamos vivendo, é claro, em um mundo de fantasia, onde o braço do pêndulo é uma haste idealizada que nunca se dobra e a massa do prumo está concentrada em um único ponto infinitamente pequeno.

No entanto, mesmo não querendo nos preocupar com todas as perguntas, nós devemos adicionar uma variável a mais para o nosso cálculo da aceleração angular. Para simplificar as coisas, em nossa derivação da aceleração do pêndulo, presumimos que o comprimento da corda é 1. Na verdade, o comprimento da corda afeta muito a aceleração: quanto maior a corda, mais lenta é a aceleração. Para simular um pêndulo com mais precisão, dividimos por esse comprimento, neste caso, armLength. Para obter uma explicação mais detalhada, visite The Simple Pendulum website.

this.aAcceleration = (-1 * gravity / this.armLength) * sin(this.angle);

Finalmente, um pêndulo do mundo real vai experimentar alguma quantidade de atrito (no ponto de pivô) e a resistência do ar. Com o nosso código do jeito que está, o pêndulo balançará para sempre, então para torná-lo mais realista, podemos usar um truque de "amortecimento". Digo truque porque ao invés de modelar as forças de resistência com algum grau de precisão (como fizemos na seção forças), podemos obter um resultado semelhante simplesmente reduzindo a velocidade angular durante cada ciclo. O código a seguir reduz a velocidade em 1% (ou multiplica por 99%) durante cada quadro de animação:

this.aVelocity *= this.damping;

Juntando tudo, temos o seguinte exemplo. Também colocamos algumas funcionalidades para facilitar na hora de arrastar o prumo e soltá-lo de diferentes alturas. Experimente!

Este curso "Natural Simulations" é um derivado do "The Nature of Code" por Daniel Shiffman, usado sob a Creative Commons Attribution-NonCommercial 3.0 Unported License.

Quer participar da conversa?

Entrar

Classificar por:

Nenhuma postagem por enquanto.

Você entende inglês? Clique aqui para ver mais debates na versão em inglês do site da Khan Academy.