Use o software python ou Matlab para graficar a resposta de vibração de:
Um sistema viscosamente amortecido com
Um sistema viscosamente amortecido com
Passo 1
O enunciado pede para graficar a resposta de vibração livre de um sistema massa-mola com amortecimento viscoso, usando Python ou Matlab.
Dados fornecidos (vou escrever todos os valores com unidades):
Dados fornecidos (vou escrever todos os valores com unidades):
Pergunta explícita: produzir um gráfico temporal de
(resposta livre dada as condições iniciais). Não preciso pedir nada a você; vou resolver direto e mostrar o código executável (Python e alternativa Matlab).
Passo 2
Escrevo a equação de movimento e explico cada termo (para você entender e poder reproduzir na prova):
A equação diferencial do sistema massa-mola-amortecedor em vibração livre é
Explicação dos termos:
-
é a massa (kg). -
é o coeficiente de amortecimento viscoso ( ). -
é a rigidez da mola ( ). -
é o deslocamento em função do tempo (m). -
é a velocidade, a aceleração.
Estamos no caso de vibração livre porque não há força externa forçando o sistema (lado direito é zero). A solução depende do chamado “razão de amortecimento” (damping ratio) — veremos qual caso temos.
Passo 3
Calculo a frequência natural não amortecida (isso é central em vibração):
A frequência natural em rad/s é
Com os valores:
Comentário prático:
diz a rapidez com que o sistema oscilaria sem amortecimento.
Passo 4
Calculo o amortecimento crítico e a razão de amortecimento:
A condição de amortecimento crítico é dada por
Logo
A razão de amortecimento (damping ratio) é
Interpretação:
, então o sistema é subamortecido (underdamped) — oscilações amortecidas exponencialmente.
Passo 5
Para o caso subamortecido a solução geral (forma padrão usada em provas) é:
onde
é a frequência amortecida:
Explicação didática: o fator
é o envelope exponencial que faz a amplitude decair; a parte trigonométrica representa a oscilação à frequência mais baixa
por causa do amortecimento.
Passo 6
Calculo
numericamente:
Também útil: período amortecido
. Isso nos ajuda a escolher o intervalo de tempo do gráfico (veremos).
Passo 7
Determino as constantes
e
a partir das condições iniciais. Primeiro, converter
para metros:
Então
Agora a derivada:
Em
isso vira
Usando
e os números já obtidos:
Calculo intermediário:
. Então
Isolando
:
Passo 8
Agora já temos todas as peças. A solução analítica (com coeficientes numéricos) é
Dica prática: para visualizar bem a decaída, plote de
até alguns segundos. Como o período é cerca de
, um intervalo de
a
s mostra várias oscilações e como a amplitude decai.
Passo 9
Código executável para plotar. Copie e cole o bloco Python em um arquivo e execute (ou cole no Jupyter). Ele usa numpy e matplotlib. Também forneço a alternativa em Matlab logo abaixo.
Python (recomendado):
import numpy as np
import matplotlib.pyplot as plt
# Parâmetros (valores do enunciado)
m = 4.0 # kg
k = 2500.0 # N/m
c = 10.0 # N s/m
x0 = 0.1 # m (100 mm)
xdot0 = -10.0 # m/s
# Cálculos auxiliares
omega_n = np.sqrt(k / m)
c_cr = 2 * m * omega_n
zeta = c / c_cr
omega_d = omega_n * np.sqrt(1 - zeta**2)
# Constantes da solução
A = x0
B = (xdot0 + zeta * omega_n * A) / omega_d
# Função solução
def x(t):
return np.exp(-zeta * omega_n * t) * (A * np.cos(omega_d * t) + B * np.sin(omega_d * t))
# Tempo para plot
t = np.linspace(0, 2.0, 2000) # 0 a 2 s, muitos pontos para suavizar
xt = x(t)
# Plot
plt.figure(figsize=(8,4))
plt.plot(t, xt, label='x(t)')
# envelope superior e inferior
envelope = np.exp(-zeta * omega_n * t) * np.sqrt(A**2 + B**2)
plt.plot(t, envelope, 'r--', linewidth=0.8, label='envelope')
plt.plot(t, -envelope, 'r--', linewidth=0.8)
plt.grid(True)
plt.xlabel('t (s)')
plt.ylabel('x (m)')
plt.title('Resposta livre amortecida: m=4 kg, k=2500 N/m, c=10 N s/m')
plt.legend()
plt.tight_layout()
plt.show()
Matlab (alternativa):
m = 4;
k = 2500;
c = 10;
x0 = 0.1;
xdot0 = -10;
omega_n = sqrt(k/m);
c_cr = 2*m*omega_n;
zeta = c / c_cr;
omega_d = omega_n*sqrt(1 - zeta^2);
A = x0;
B = (xdot0 + zeta*omega_n*A)/omega_d;
t = linspace(0,2,2000);
x = exp(-zeta*omega_n*t).*(A*cos(omega_d*t) + B*sin(omega_d*t));
plot(t,x,'b'); hold on;
envelope = exp(-zeta*omega_n*t)*sqrt(A^2 + B^2);
plot(t,envelope,'r--',t,-envelope,'r--');
grid on;
xlabel('t (s)');
ylabel('x (m)');
title('Resposta livre amortecida');
legend('x(t)','envelope');
Observações para a prova e para você:
- Confirme sempre unidades (x0 em metros).
- Se precisar do gráfico em mm, multiplique
por . - Para checar: em
o gráfico deve começar em e a derivada inicial aproximar . - Se quiser ver menos ciclos, reduza o tempo final; para ver amortecimento até quase zero, aumente.
Resposta
(Código Python executável fornecido no Passo 9 para gerar o gráfico; alternativa Matlab também fornecida.)