CEDERJ - CENTRO DE EDUCAÇÃO SUPERIOR A DISTÂNCIA
DO ESTADO DO RIO DE JANEIRO
MATERIAL DIDÁTICO IMPRESSO
ORIENTAÇÔES PARA A ELABORAÇÃO DO PLANEJAMENTO DE UMA AULA
CURSO: Física
DISCIPLINA: Informática para o Ensino de Física
CONTEUDISTA: Carlos Eduardo Aguiar
AULA 9
TÍTULO: Controlando Simulações no Modellus
META DA AULA
Apresentar os métodos de controle de simulações disponíveis no Modellus.
OBJETIVOS
Esperamos que, após o estudo do conteúdo desta aula, você seja capaz de:
•
Desenvolver no Modellus simulações que podem ser controladas interativamente.
•
Utilizar instruções de controle se-então em simulações no Modellus.
1
Simulações interativas no Modellus
Videogames estão entre as aplicações mais populares dos computadores, para o bem ou
para o mal das novas gerações. Uma característica interessante do Modellus é que podemos
usá-lo para criar ambientes semelhantes a esses jogos, ou seja, simulações com as quais
podemos interagir enquanto elas estão sendo executadas. Isso abre novas possibilidades
para o uso do Modellus, que exploraremos nesta aula. Vamos começar criando uma
simulação interativa bem simples: na janela Modelo, escreva x (isso mesmo, apenas a letra
“x”), como está mostrado na Figura 9.1.
Figura 9.1: Modelo com parâmetro (x) a ser controlado interativamente.
Agora interprete o modelo. Você verá que a janela Condição Inicial é criada, e x aparece
como um parâmetro a ser especificado (veja a Figura 9.2). O valor x = 0 é colocado por
default na janela e pode ser alterado, mas não há problema em deixá-lo assim. Como
veremos, esse será apenas o valor inicial de x, que aprenderemos a mudar de forma
interativa.
Figura 9.2: Janela com o valor inicial do parâmetro x.
O próximo passo é colocar na janela de animação um objeto com os quais podemos
interagir e, por seu intermédio, controlar o valor da variável x. Para isso, crie um objeto
Barra com valor dado por x, tal como está mostrado na Figura 9.3. Note que o valor
máximo de x foi fixado em 100. Em seguida, crie um objeto Partícula na mesma janela e
defina sua posição horizontal como sendo x (veja a Figura 9.4). Com esses dois objetos
criados, a janela Animação deve ficar parecida com o que está na Figura 9.5.
2
Figura 9.3: Propriedades do objeto Barra.
Figura 9.4: Propriedades do objeto Partícula.
Figura 9.5: A janela de animação com a barra e a partícula.
3
Para que a simulação não termine muito rapidamente, aumente o limite máximo da variável
independente t para um valor bem grande, como 1000 (lembre que isso é feito com o botão
Opções da janela de controle). Isso nos dará tempo suficiente para explorar os controles
introduzidos. Finalmente, execute a simulação. Como você já deve ter imaginado, nada
acontece, já que o modelo interpretado não determina como x depende de t. Entretanto, há
uma forma interativa de mudar o valor de x. Enquanto a simulação estiver rodando,
coloque o cursor sobre a barra que foi criada na janela de animação – você verá que o
cursor muda de aspecto, ganhando uma forma de “mão”, como mostrado na Figura 9.6. Use
esse “cursor/mão” para levantar e baixar a barra, e note como isso muda o valor de x
(lembre que o nível da barra está associado x, veja a Figura 9.3). O mais interessante é que
a posição da partícula também muda quando movemos a barra. É fácil entender isso: basta
lembrar que o valor da variável x também determina o deslocamento horizontal da partícula
(veja a Figura 9.4). Observe que esta simulação é bem diferente de todas as que já criamos
com o Modellus – em vez de uma definição matemática de como a posição x da partícula
depende do tempo t, agora controlamos à vontade a posição da partícula, usando para isso o
nível da barra. É importante ressaltar que essa interação só pode ocorrer enquanto a
simulação estiver sendo executada – foi por isso que sugerimos aumentar muito o valor
máximo de t. Se o tempo acabar, ou a simulação for interrompida, não será mais possível
controlar interativamente a variável x.
Figura 9.6: Controle da posição da partícula com o nível da barra.
Também é possível usar a partícula para controlar o nível da barra. Ao colocar o cursor
sobre a partícula, enquanto a simulação estiver rodando, você verá novamente a “mão”
aparecer, tal como está na Figura 9.6. Como no caso da barra, podemos então deslocar a
partícula, mudando o valor de x. Com isso, o indicador da barra também muda,
acompanhando o movimento damos à partícula.
Você pode interromper a simulação a qualquer momento, usando o botão apropriado na
janela de controle. A interrupção “desliga” a interatividade, que só retorna quando a
execução do programa é retomada.
4
Figura 9.7: Controle da barra com a partícula.
Controlando a velocidade de um carro
Vamos agora fazer um programa interativo mais interessante. Em vez de mudar a posição
da partícula, vamos controlar a sua velocidade. Para isso, comece um novo programa e
escreva na janela Modelo a equação dx/dt = v, tal como está na Figura 9.8. Essa é uma
equação diferencial como as que já estudamos em outras aulas – sabemos que o Modellus
vai resolvê-la e calcular a posição x(t) da partícula. Mas, ao contrário dos casos anteriores, a
velocidade v não será dada por uma constante, ou uma função, ou ainda por outra equação
diferencial – ela será definida interativamente à medida que o programa for sendo
executado.
Figura 9.8: Modelo para controle da velocidade.
Quando o modelo é interpretado, a janela Condições Iniciais é criada pedindo o valor da
velocidade v e a condição inicial para x. Novamente, não há problema em deixar inalterados
os valores definidos pelo próprio Modellus. O próximo passo é produzir um controle da
velocidade v. Para isso vamos usar, de novo, um objeto Barra da janela Animação. Os
passos para a criação de uma barra associada à variável v já são bem familiares, e não
vamos repeti-los. O resultado está mostrado na Figura 9.9. Note que escolhemos os limites
máximo e mínimo dos valores de v definidos na barra como sendo 10 e -10,
respectivamente. A Figura 9.9 também mostra a partícula, cuja posição é dada pela variável
x. Em vez de representar a partícula por uma bolinha, como no exemplo anterior, desta vez
usamos um carro. A figura do carrinho está no arquivo Car.bmp que encontra-se entre as
imagens fornecidas pelo Modellus, já utilizadas na Aula 7 (se você não lembra onde salvou
5
as imagens, não se preocupe – pode continuar a usar uma bolinha para representar a
partícula).
Figura 9.9: Partícula (carro) com velocidade controlada pela barra.
Os próximos passos já são conhecidos: aumente para um valor bem grande o limite máximo
do tempo t (usando as opções da janela de controle), interprete o modelo e execute-o.
Durante a execução, use o mouse para levantar e abaixar a barra, alterando assim a
velocidade do carrinho. Se tudo deu certo, você será capaz de fazer o carro andar para
frente e para trás, controlando seu movimento à vontade. Os gráficos da Figura 9.10
mostram a velocidade e a posição do carrinho após uma simulação interativa típica. É
instrutivo discutir a relação entre os gráficos da velocidade e do deslocamento durante esse
tipo de simulação.
Figura 9.10: Gráficos da velocidade (à esquerda) e posição (à direita) do carro.
Controlando a aceleração do carro
É fácil fazer um programa em que a aceleração do carro é controlada, em vez da
velocidade. Basta escrever, na janela Modelo, dx/dt = v e dv/dt = a, como mostrado na
Figura 9.11. Note que apenas adicionamos uma equação ao modelo anterior. Esta segunda
equação define a velocidade, que deixa de ser um parâmetro livre e não pode mais ser
controlada interativamente. O que está livre para ser alterado, agora, é a aceleração a.
6
Podemos usar a barra que já está na janela de animações para controlar a aceleração; basta
mudar suas propriedades e associa-la ao valor de a, como se vê na Figura 9.12. Observe
que colocamos os valores máximo e mínimo da barra em a = 2 e a = -2.
Figura 9.11: Modelo para controle da aceleração.
Figura 9.12: Carro com controle de aceleração.
Gráficos da aceleração, velocidade e posição do carro obtidos numa simulação em que a
aceleração foi controlada interativamente estão mostrados na Figura 9.13.
Figura 9.13: Aceleração, velocidade e posição do carro.
7
Instruções de controle: o comando if-then (se-então)
Nas simulações interativas, o usuário do Modellus resolve que rumos o programa toma
durante a execução. Existe uma forma de dar poder de “decisão” semelhante ao próprio
programa. Por exemplo, podemos fazer com que uma simulação resolva sozinha a hora em
que deve parar. Para ver um exemplo concreto disso, vamos estudar um corpo que cai de
uma altura de 100 metros. Desprezando a resistência do ar e considerando g = 9,8 m/s2, o
movimento do corpo será dado por y = 100 – 4,9t2, onde a altura y e o tempo t estão em
metros e segundos, respectivamente. Essa fórmula só vale enquanto o corpo está acima do
solo, e por isso gostaríamos de terminar a simulação assim que a altura y se torne negativa.
O modelo mostrado na Figura 9.14 mostra como fazer tal coisa. A primeira linha define a
queda livre do corpo, e a segunda determina que a simulação seja interrompida no instante
em que a condição y < 0 for satisfeita. O comando que implementa essa decisão tem uma
estrutura se-então: se a condição A ocorrer, então realize a ação B. No Modellus, o “se” e o
“então” são escritos em inglês, como “if” e “then”. Assim, escrevemos “if (A) then (B)”,
em vez de “se (A) então (B)”. No modelo mostrado na Figura 9.14 temos a instrução
if (y < 0) then (t_final = stop (t))
ou seja, a condição A é y < 0, e a ação B é a interrupção do programa. Esta última é feita
com a instrução “t_final = stop(t)”, que faz duas coisas: termina a execução do programa
(para isso serve o stop, que significa “pare” em inglês) e atribui à variável t_final o valor de
t em que ocorre a interrupção.
Figura 9.14: Simulação de queda livre. A execução do
programa termina quando a altura torna-se negativa.
Interpretando e executando o modelo acima, encontramos o resultado mostrado no gráfico
da Figura 9.15. A trajetória da partícula é traçada apenas até o instante em que ela cruza o
eixo horizontal, ou seja, até que y fique negativo. Nesse instante (algo entre 4 e 5 segundos)
a execução do programa termina, embora o tempo máximo fixado na janela de controle seja
20 segundos. Se quisermos saber exatamente o ponto em que o programa parou, podemos
escrever o valor da variável t_final na janela de animações. A Figura 9.16 mostra como isso
é feito usando um medidor digital (criado com o botão que tem um “x = ?” desenhado). Ao
final da simulação, o medidor mostra que a execução foi interrompida em t_final = 4,6
segundos.
8
Figura 9.15: Queda livre interrompida quando y < 0.
Figura 9.16: O tempo final escrito no medidor digital.
É importante notar que o corpo atinge o solo em t = 100 / 4,9 = 4,52 segundos, ou seja,
t_final não é exatamente o tempo de queda. O programa pára no primeiro passo em que
y < 0, não quando y = 0. É fácil ver que a diferença entre o tempo de queda e t_final é
menor que a duração de um passo da simulação. Portanto, para fazer com que t_final
represente melhor o tempo de queda, basta diminuir o tamanho do passo (janela de
controle, botão Opções). Podemos tentar parar o programa quando y = 0, usando
“if (y = = 0) then (t_final = stop (t))”. Entretanto, isso dificilmente funciona, pois é
muitíssimo improvável que um dos passos do programa caia exatamente em y = 0 (com
todas as casas decimais necessárias). Repare também na forma como a condição y = 0 é
escrita no comando if-then: y = = 0, com duplo “=”. Para ver mais sobre a sintaxe do
comando if-then, procure o programa de ajuda do Modellus.
Salto de pára-quedas
O comando if-then não serve apenas para terminar a simulação: ele pode ser usado para
atribuir valores a parâmetros. Vamos fazer isso estudando o movimento de um páraquedista. A resistência do ar sentida pelo pára-quedista é, em boa aproximação,
9
proporcional ao quadrado da velocidade de queda. A força total sobre o pára-quedista é
então
F = mg − kv 2
onde mg é o peso do pára-quedista, v é a sua velocidade e k é uma constante que caracteriza
a importância da resistência do ar. Antes de o pára-quedas abrir-se, o valor de k é pequeno,
correspondendo apenas à resistência encontrada pelo corpo do pára-quedista. Um valor
típico nesse caso é k = 0,5 kg/m. Quando o pára-quedas é aberto, a resistência do ar
aumenta muito, e o valor de k sobe para algo como k = 40 kg/m. Vamos supor que o páraquedista abre o pára-quedas é após um tempo t0 de queda livre. Um modelo para o cálculo
da velocidade desse pára-quedista está mostrado na Figura 9.17. Note como a abertura do
pára-quedas foi modelada com as duas instruções de controle if-then.
Figura 9.17: Modelo de um pára-quedista que abre
o pára-quedas após um tempo t0 em queda livre.
A velocidade do pára-quedista está mostrada na Figura 9.18. O tempo de queda livre foi
fixado em t0 = 6 s. A massa do pára-quedista é m = 80 kg e a aceleração da gravidade é g =
9,8 m/s2.
Figura 9.18: Velocidade do pára-quedista antes
e depois da abertura do pára-quedas.
10
Existem muitas outras maneiras de se usar o comando if-then. É possível combinar duas
condições, usando as operações “e” e “ou”, que são escritas em inglês no Modellus, como
“and” e “or”. Também é possível usar o “and” para executar mais de uma ação. O programa
de ajuda mostra como isso tudo pode ser feito.
INFORMAÇÕES SOBRE A PRÓXIMA AULA
Esta foi a última aula sobre o Modellus. Na próxima aula iniciaremos nosso estudo da
linguagem de programação Logo.
11