Considere o modelo de entrada-saída na equação [Consider the input-output model in equation] (2):
d^2 y(t)d t^2+2 d y(t)d t+y(t)=4 d^2 u(t)d t+15 d u(t)d t+19 u(t)
Por meio da linguagem de programação de sua escolha, plote a resposta y(t) e comente seus resultados [By means of the programming language of your choice, plot the response y(t) and comment on your results].

Passo 1

Beleza, vamos resolver esse exercício juntos! O enunciado nos dá uma equação diferencial de segunda ordem que relaciona a saída com a entrada . Nosso objetivo é encontrar e plotar essa resposta usando uma linguagem de programação. Para isso, vamos precisar entender um pouco de equações diferenciais e de como resolvê-las usando programação, como por exemplo, o Python.

Passo 2

Primeiro, vamos entender a equação que temos:
d^2 y(t)d t^2 + 2 d y(t)d t + y(t) = 4 d^2 u(t)d t + 15 d u(t)d t + 19 u(t)
Essa é uma equação diferencial linear de segunda ordem, onde é a saída e é a entrada. Queremos encontrar em função de .

Passo 3

Para resolver essa equação, vamos usar o Python com as bibliotecas numpy, scipy e matplotlib. Essas ferramentas nos permitem resolver equações diferenciais numericamente e plotar os resultados de forma fácil.

Passo 4

Primeiro, vamos reescrever a equação diferencial de forma que possamos usar uma função para representá-la. Para isso, precisamos expressar a equação em termos de derivadas de .
Vamos considerar que a entrada é uma função conhecida. Para simplificar, vamos assumir que é uma função degrau, ou seja, ela é zero para e um para .

Passo 5

Agora, vamos reescrever a equação diferencial para facilitar a implementação no Python. Podemos isolá-la para obter uma expressão do tipo:
d^2 y(t)d t^2 = 4 d^2 u(t)d t + 15 d u(t)d t + 19 u(t) - 2 d y(t)d t - y(t)
Isso nos ajudará a criar uma função que calcula as derivadas necessárias para resolver numericamente a equação.

Passo 6

Vamos implementar isso no Python. Aqui está o código que faz isso:
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

# Define a função de entrada u(t) como um degrau
def u(t):
    return 1 if t >= 0 else 0

# Define a equação diferencial
def eq_diff(t, Y):
    y, dy = Y
    d2y = 4 * 0 + 15 * 0 + 19 * u(t) - 2 * dy - y  # Como u(t) é constante após t=0, suas derivadas são zero
    return [dy, d2y]

# Intervalo de tempo
t_span = (0, 10)
t_eval = np.linspace(t_span[0], t_span[1], 1000)

# Condições iniciais: y(0) = 0, y'(0) = 0
Y0 = [0, 0]

# Resolve a equação diferencial
sol = solve_ivp(eq_diff, t_span, Y0, t_eval=t_eval)

# Plota a solução
plt.plot(sol.t, sol.y[0], label='y(t)')
plt.title('Resposta y(t) da Equação Diferencial')
plt.xlabel('Tempo t')
plt.ylabel('y(t)')
plt.legend()
plt.grid(True)
plt.show()

Passo 7

Vamos explicar o que cada parte do código faz:
  • Importações: Importamos as bibliotecas necessárias.
  • Função de entrada : Definimos como um degrau, que vale 1 para .
  • Equação Diferencial: Criamos a função eq_diff que representa a equação diferencial. Aqui, assumimos que é constante após , então suas derivadas são zero.
  • Intervalo de Tempo: Definimos o intervalo de tempo para a solução, de 0 a 10 segundos, e criamos um vetor de pontos de tempo onde a solução será avaliada.
  • Condições Iniciais: Consideramos que a saída e sua derivada inicial são zero.
  • Resolução da Equação: Usamos a função solve_ivp do scipy para resolver a equação diferencial.
  • Plotagem: Finalmente, plotamos em função do tempo.

Passo 8

Ao executar esse código, vamos obter um gráfico que mostra como a saída reage ao longo do tempo em resposta ao degrau de entrada . Geralmente, esperamos ver uma curva que se estabiliza em um valor constante após algumas oscilações ou flutuações iniciais, dependendo dos coeficientes da equação diferencial.

Resposta

Através do código implementado, obtivemos o gráfico da resposta da equação diferencial dada. O gráfico mostra como a saída reage ao degrau de entrada ao longo do tempo, estabilizando-se em um valor constante após um período de transição.

Exercícios relacionados