Na linguagem de programação de sua escolha, simule a resposta de dois sistemas a entrada ao degrau de amplitude A de sua escolha e discuta seus resultados.

Passo 1

Beleza, vamos lá! O exercício pede para a gente, usando uma linguagem de programação (pode ser Python, por exemplo), simular como dois sistemas respondem a uma entrada em degrau com amplitude A que a gente escolher. Basicamente, vamos precisar entender o que é uma entrada em degrau, como os sistemas respondem a ela e depois programar isso para ver os resultados.

Passo 2

Primeiro, vamos entender o que é uma entrada em degrau. É uma função que muda de zero para um valor constante A de repente, tipo um interruptor ligado de uma vez só. Matematicamente, a entrada em degrau pode ser representada como:
u(t) = 0, & t < 0 A, & t >= 0
Esse tipo de entrada é muito usado para testar sistemas porque nos ajuda a ver como o sistema reage a uma mudança súbita.

Passo 3

Agora, precisamos definir o que são os dois sistemas que vamos simular. Vamos supor que são dois sistemas de primeira ordem diferentes, cada um com sua própria constante de tempo ( tau). A resposta de um sistema de primeira ordem a uma entrada em degrau é dada pela equação:
y(t) = A (1 - e^-ttau)
Onde:
  • y(t) é a saída do sistema no tempo t.
  • A é a amplitude da entrada em degrau.
  • tau é a constante de tempo do sistema, que determina a rapidez com que o sistema responde.

Passo 4

Vamos escolher a linguagem de programação Python para essa simulação, pois é bastante acessível e tem bibliotecas que facilitam esses cálculos, como o NumPy e o Matplotlib para plotar os resultados.

Passo 5

Vamos definir os parâmetros para os dois sistemas. Por exemplo:
  • Sistema 1: tau1 = 1 segundo
  • Sistema 2: tau2 = 3 segundos
  • Amplitude do degrau: A = 5
Esses valores nos permitirão ver como diferentes constantes de tempo afetam a resposta do sistema.

Passo 6

Agora, vamos criar uma função em Python que calcula a resposta de um sistema de primeira ordem a uma entrada em degrau:
import numpy as np
import matplotlib.pyplot as plt

def resposta_degrau(t, A, tau):
    return A * (1 - np.exp(-t / tau))
Essa função recebe o tempo t, a amplitude A e a constante de tempo tau, e retorna a saída y(t).

Passo 7

Vamos definir o intervalo de tempo para a simulação. Por exemplo, de 0 a 10 segundos, com pequenos incrementos para ter uma curva suave:
t = np.linspace(0, 10, 1000)

Passo 8

Agora, vamos calcular as respostas para os dois sistemas usando a função que criamos:
A = 5
tau1 = 1
tau2 = 3

y1 = resposta_degrau(t, A, tau1)
y2 = resposta_degrau(t, A, tau2)

Passo 9

Vamos plotar esses resultados para visualizar como cada sistema reage à entrada em degrau:
plt.plot(t, y1, label=f'Sistema 1 (tau={tau1}s)')
plt.plot(t, y2, label=f'Sistema 2 (tau={tau2}s)')
plt.title('Resposta a Degrau de Dois Sistemas de Primeira Ordem')
plt.xlabel('Tempo (s)')
plt.ylabel('Saída y(t)')
plt.legend()
plt.grid(True)
plt.show()

Passo 10

Ao rodar esse código, você vai ver duas curvas. O Sistema 1, com tau = 1 segundo, vai atingir o valor de A = 5 mais rapidamente, enquanto o Sistema 2, com tau = 3 segundos, vai levar mais tempo para chegar ao mesmo valor. Isso acontece porque a constante de tempo tau indica quão rápido o sistema reage à entrada: quanto menor tau, mais rápido a resposta.

Resposta

Simulando as respostas, observamos que o Sistema 1, com uma constante de tempo menor, atinge rapidamente a amplitude A = 5, enquanto o Sistema 2, com uma constante de tempo maior, demora mais para estabilizar no mesmo valor. Isso mostra que a constante de tempo influencia diretamente na rapidez com que um sistema responde a uma entrada em degrau.

Exercícios relacionados