MAMI – Aula Remota 4:

MRUV
Melo Jr. - SMD/UFC - 2020
E a diferença que um “V” faz!
Agora que você já conhece melhor os
três modelos, vamos logo a eles:
Modelo Natural
MRUV significa Movimento Retilíneo
Uniformemente Variado.
De antemão, devido à aula
passada, já sabemos bem o que
são “Movimento” e “Retilíneo”.
No entanto, falta esse
“uniformemente variado” aí...
Como sabemos que, no MRU,
“uniforme” diz respeito a constância,
então o “uniformemente variado”
refere-se a constância na variação.
Mas o que quer dizer essa
“constância na variação”?
Dica: tem a ver com aceleração.
Recapitulando: aceleração é uma
taxa de variação na velocidade,
aumentando-a ou diminuindo-a
(respectivamente se a aceleração for
positiva ou negativa).
Se essa aceleração for constante,
a velocidade aumentará ou
diminuirá uniformemente.
E, se esse movimento se der em linha
reta, então teremos um movimento
retilíneo uniformemente variado.
Para compreender melhor, como
sempre, vamos a um exemplo:
Digamos que agora você foi de
bicicleta, novamente em linha reta,
do portão de sua casa àquela padaria
da esquina.
E se você continua com um controle corporal
perfeito e conseguiu manter uma aceleração
realmente constante durante todo o trajeto,
então ocorreu um movimento retilíneo
uniformemente variado.
Como assim?!
Para ficar mais fácil, vamos aos
números...
Digamos que você estava parado
e partiu do portão de sua casa
com uma aceleração de 1 m/s . 2
Observação: pouca gente entende
esse 1 m/s2, mas isso quer dizer
somente que ocorre uma variação na
velocidade de 1 m/s a cada 1 s.
Ou seja, 1 m/s / s = 1 m/s .
2
Continuando nosso exemplo, você
sabe em qual velocidade estará logo
após o primeiro segundo de
pedalada?
Bem, você estava parado, então a
velocidade inicial era de 0 m/s. Como se
passou só 1 s e a aceleração era 1 m/s2,
então a velocidade naquele momento
(velocidade instantânea) será 1 m/s.
E, continuando, passado mais um segundo a
velocidade instantânea iria para 2 m/s; e mais
um segundo, 3 m/s; e assim por diante até
você atingir a velocidade da luz ou, muito
provavelmente, cair da bicicleta.
Velocidade da luz: uma das principais constantes da Física mede 299.792.458 m/s.
E uma perguntinha: como a velocidade da Luz é medida?
Note que, depois de compreender
bem o que é a aceleração, o
raciocínio se torna bem simples e,
agora, podemos seguir em frente...
Mais uma questão: 1 m/s2 é muito ou pouco? Como referência, você sabe qual foi a
maior aceleração já experimentada pelos astronautas da Falcon 9, SpaceX?
Modelo Matemático
Mais uma vez é necessário
estabelecer variáveis considerando o
modelo natural original.
Variáveis do MRUV:
d: deslocamento realizado
v0: velocidade inicial
t: tempo decorrido
Mas você notou algo estranho?
Explicação: o modelo matemático que
trabalharemos não considerou a
velocidade instantânea do exemplo; mas,
sim, o deslocamento realizado (que nem
estava no exemplo).
Lembre-se que o modelo matemático é uma simplificação do modelo natural,
geralmente considerando somente um aspecto específico do mesmo.
Fizemos essa opção por que
queremos simular particularmente o
deslocamento (o aspecto específico
citado no slide anterior) realizado por
um corpo em MRUV.
Não é o caso de um simples MRUV, porém matematizar todo um modelo natural
pode ser bem complexo – na verdade, muitas vezes até impossível, considerando as
limitações técnicas e tecnológicas da humanidade, vide previsão do tempo e afins.
(de todo modo, acompanhando o
raciocínio direto desenvolvido no modelo
natural, você já deve ter chegado à
conclusão que v = v0 + a . t, onde v seria a
velocidade instantânea).
Então, com base nas variáveis
definidas, obtemos:
d = v0 . t + a . t2 / 2
Apesar dessa fórmula ser uma aplicação direta de Cálculo Diferencial e Integral –
sim, ele serve para alguma coisa! –, uma demonstração, digamos, indireta e
engenhosa envolve somente geometria básica: https://youtu.be/s8pX2AQkw9I.
No entanto, antes de prosseguir
precisamos realizar uma simples,
porém importante, transformação:
De:
d = v0 . t + a . t2 / 2
Para:
d = v0 . t + a . t . t / 2
Logicamente, as duas fórmulas
anteriores são equivalentes, mas –
pelo menos por enquanto – é mais
fácil e didático implementar, através
de código, a segunda versão.
Modelo Computacional
Agora, simplesmente considerando os
raciocínios já desenvolvidos na aula
anterior, sobre MRU, e empregando como
base o respectivo código da respectiva
tarefa já realizada, obtemos:
Caso necessário, revise como o modelo matemático foi compatibilizado com o
modelo computacional na aula anterior – todos os detalhes sórdidos estão lá – e
utilize nosso fórum para discutir algo que talvez você não tenha compreendido.
 void draw() {
background(255);
float tAtual = 0; dAtual = MRUV(vInicial, aAtual, tAtual);
println("Tempo: " + tAtual);
float vInicial = 0;
println("Deslocamento: " + dAtual);
float aAtual = 1; println();
float dAtual; ellipse(dAtual, 300, 10, 10);
float intervalo = 1.0/60; tAtual = tAtual + intervalo;
}
void setup() {
float MRUV(float v, float a, float t){
size(600, 600); float d;
} d = v * t + a * t * t / 2.0;
return(d);
}
Antes de tudo, você poderia utilizar as
funções sq() ou pow() na seguinte linha:
d = v * t + a * t * t / 2.0;
Porém, como dito antes, é mais fácil e
didático deixar assim, por enquanto.
Se você não as conhece, pesquise para que servem as funções sq() e pow() do
Processing.
Ao executar esse código, tente
identificar sua relação com o
exemplo que estávamos trabalhando
antes: bicicleta, velocidade da luz, ...
Note como o corpo simulado parte
do repouso e, com o tempo, vai
ganhando velocidade.
Agora modifique as variáveis,
identificando o comportamento de
cada uma delas e suas interelações
nos três modelos (natural,
matemático e computacional).
Não se esqueça de também testar
valores negativos...
Então você consegue simular, por
exemplo, uma freada em alta velocidade?
Agora inclua o bom e velho
procedimento mostraMundo() e
compare o resultado desse código
com o do MRU, da aula passada.
Experimente também manter ou
retirar o “rastro” (as réplicas deixadas
pelo movimento) do corpo.
Se você fez bem a tarefa da aula anterior, deve saber que manter ou retirar o rastro
só depende da localização do comando background() no código. Caso contrário,
que tal debater no fórum?
Note como a presença ou ausência
de linhas e rastros influencia na
análise da velocidade dos corpos
tanto no MRU quanto no MRUV!
Mais uma vez, compare os resultados dos
códigos desenvolvidos de MRU e de
MRUV e os respectivos comportamentos
dos corpos simulados.
Simulador Gráfico
de Lançamento Oblíquo
em Tempo Real
Antes que você se esqueça, lembre
que nosso objetivo sempre foi criar
um simulador gráfico de lançamento
oblíquo em tempo real.
E, por mais incrível que pareça, se
você chegou “bem” até aqui, então já
o tem neste exato momento!
Provavelmente você nem notou, mas
nessas três aulas sobre
procedimentos e funções nós
adotamos o dividir para conquistar
para desenvolver esse simulador.
Ou seja, dividimos o problema do
simulador em questões bem mais
simples: tempo real, correspondência
espacial, MRU, MRUV, etc.
Mas o que tudo isso, afinal, tem a ver
com o simulador gráfico de
lançamento oblíquo em tempo real?
Antes de chegar lá, porém, vamos
realizar algumas alterações pontuais
no código do MRUV:
 void draw() {
background(255);
float tAtual = 0; dAtual = MRUV(vInicial, aAtual, tAtual);
println("Tempo: " + tAtual);
float vInicial = 100;
println("Deslocamento: " + dAtual);
float aAtual = -9.8; println();
float dAtual; ellipse(300, 600 - dAtual, 10, 10);
float intervalo = 1.0/60; tAtual = tAtual + intervalo;
}
void setup() {
float MRUV(float v, float a, float t){
size(600, 600); float d;
} d = v * t + a * t * t / 2.0;
return(d);
}
As três linhas alteradas (negritadas
no código anterior) geraram um
simulador de lançamento vertical.
Tente compreendê-las.
Caso haja algum problema, particularmente na alteração da instrução elipse(),
acesse nosso fórum.
Nesse simulador, um corpo é lançado
verticalmente a uma velocidade inicial de
100 m/s, então sofrendo a ação da
gravidade (aceleração de -9,8 m/s2).
Altere livremente os valores das
variáveis para experimentar as
possibilidades.
E agora, já consegue criar o
simulador gráfico de lançamento
oblíquo em tempo real?
Observe:
...mas é claro que tem de ter COVID!!!
E assista:
Complementando:
Até aonde vai o seu ESPIRRO???,
https://youtu.be/s56vt9jE__c
(E Cuidado! Ao que tudo indica, o problema
do distanciamento não é tão simples assim:
https://youtu.be/hJGDFbk7ER8)
Apesar da imagem e do vídeo não
caracterizarem um lançamento
oblíquo completo, que normalmente
descreve uma parábola no ar, algo
fica bem patente:
Devido ao atrito com o ar, no mundo concreto, tal parábola nunca seria “perfeita”,
sofrendo algum tipo de deformação. No entanto, como nossos três modelos
descartaram tal “detalhe”, então consideraremos que está tudo oficialmente
correto.
É possível decompor um lançamento
oblíquo em dois movimentos mais
simples, sendo um MRU na horizontal e
um MRUV na vertical:
https://slideplayer.com.br/slide/7722335/
E agora?
Considerando o dividir para
conquistar, perceba que você já
possui todas peças do “quebra-
cabeças”...
Tarefa
Considerando o dividir para
conquistar, agora é hora de montar
esse “quebra-cabeças”.
Para tanto, tente seguir os próximos
passos:
Aproveitando que você está se tornando especialista em utilizar serviços para
trabalhos remotos, que tal realizar esta tarefa em duplas ou trios virtuais?
1. Rabisque, em papel, exemplos de
lançamentos oblíquos e determine os
valores específicos (velocidades iniciais
horizontal e vertical, gravidade, etc.) de
um modelo que você tenha
experimentado e compreendido bem;
2. No Processing, crie um código inicial
reutilizando as função MRU() e MRUV(),
que você já desenvolveu;
3. Por enquanto, desconsidere qualquer
representação gráfica – isso é importante
pois simplificará a verificação inicial dos
valores calculados;
Lembre-se de sempre utilizar a instrução println() do Processing para verificar
valores de variáveis.
4. Defina as variáveis globais
necessárias (aquelas referentes aos
rabiscos no papel) e lembre-se que
deverá haver um único tempo, que é
o mesmo para MRU e MRUV;
Nada de definir duas variáveis para tempo, horizontal e vertical :)
5. Na função main() desse novo código,
fazendo chamadas às funções MRU() e
MRUV(), calcule as distâncias horizontal e
vertical percorridas no lançamento
oblíquo simulado;
6. Acompanhe os resultados
apresentados no console, fazendo ajustes
no código até garantir que os valores
calculados no programa condizem com
aqueles estabelecidos no papel;
Se for o caso, utilize a função de debug do Processing: https://youtu.be/03WXKb422w0.
7. Quando todos os cálculo estiverem
corretos, experimente mudar as variáveis
envolvidas e avaliar se os respectivos
resultados estão corretos.
8. Agora é só incluir os recursos gráficos
necessários – não esqueça o
mostraMundo() – e continuar com os
testes até ter certeza que você conseguiu.
9. Crie um documento com os resultados
obtidos em diferentes simulações e
poste-o como resultado da tarefa.
Por exemplo, esses resultados podem ser sequências de imagens obtidas no
simulador acrescidas de sua próprias anotações, incluindo valores numéricos
obtidos no console.
10. Parabéns, você finalmente criou o
Simulador Gráfico de Lançamento
Oblíquo em Tempo Real!
Note quão importante é primeiro
estabelecer exemplos no papel, para só
depois trabalhar modelos numéricos e,
por fim, incluir as respectivas
representações gráficas necessárias.
Esse processo vai se repetir bastante durante toda a disciplina de MAMI...
MAMI
SMD/UFC - 2020