TRABAJO FINAL DE PROCESAMIENTO DIGITAL DE SEÑALES,

DISEÑO DE FILTRO IIR (BUTTERWORTH)

Introducción:
En esta era digital de las comunicaciones el procesamiento digital de señales mediante
filtros se ha vuelto una herramienta importante. Debido a que nos ayudan a solucionar
muchos problemas en varios rubros de las telecomunicaciones.

Marco teórico:
Filtro digital:

Un filtro digital es un tipo de filtro que opera sobre señales discretas y cuantizadas,
implementado con tecnología digital, bien como un circuito digital o como un programa
informático.
Como sabemos un filtro digital de respuesta infinita (IIR) tiene la siguiente forma:

Como podemos apreciar en la ecuación no solo depende de los valores ponderados de la

señal de entrada, sino también de valores anteriores ponderados de la misma salida del
filtro dado.
 Con un filtro IIR de orden bajo llegamos a obtener características que se asemejan
mucho a un filtro FIR de orden alto. Pero siempre en el diseño de filtros va a existir
inestabilidad para ciertos parámetros y para ellos es donde tenemos una variedad
filtros para cada aplicaciones que requeramos.
 Para el diseño de los filtros IIR nos vamos a apoyar en los filtros analógicos que
consta de los siguientes pasos. Las especificaciones que usaremos para el Analógico
lo tenemos que usar para las digitales, luego sacar la función de transferencia del
filtro analógico para luego discretizar la función de transferencia y finalmente
vamos a verificar la si la respuesta del filtro sea la deseada.
 La ventaja de filtros IIR con respecto a los FIR es que requieren menor cantidad de
coeficientes para desarrollar el filtrado y esto en consecuencia son más rápido y
poco uso de RAM.

Algunos de los tipos de filtros analógicos más conocidos son los siguientes:

1. Butterworth: Presenta una respuesta monótona (sin rizado) tanto en la banda de paso
como en la de paro. Es por esta razón que tiene una considerable anchura de la banda de
transición.
2. Chevyshev tipo I: Presenta rizado en la banda de paso y respuesta monótona en la banda
de paro.
 3. Chevyshev tipo II: Presenta rizado en la banda de paro y respuesta monótona en la
banda de paso.
4. Elíptico: Presenta el mismo rizado en ambas bandas.

en la implementación del siguiente proyecto usaremos el filtro Butterworth.

Filtro Butterworth:

De estos filtros más conocidos vamos a usar el Butterworth debido a que no presenta rizados en
ninguna de las bandas, donde también vamos a ver que existen de diferentes tipos de orden N.

El orden del filtro nos indica la pendiente de bajada del filtro, mientras el orden sea mayor
tendera a ser una ventana rectangular generando un filtro ideal, pero por costos en el
desarrollo del filtro en la vida real consideramos que el orden debe no ser muy alto debido a
que crear dicho filtro nos elevaría considerablemente el costo de ello.
a) Convertir el archivo seleccionado x(t) a un archivo x[n] en formato SonidoK.txt.

Toma de muestras del audio.

Empezaremos por tomar el archivo Pajaros_01.wav y haremos la conversión a x[n] en formato
SonidoK.txt, para esto nos apoyaremos en el código escrito en el lenguaje de programación Python
toma_de_muestras.py (Anexo: Código toma_de_muestras.py)

1.- Se procede a importar las librerías necesarias para la conversión a x[n] del archivo .wav
correspondiente, en la línea 8 importaremos la librería numpy que es usada para trabajar con
arreglos, en la línea 9 tenemos a scipy.io del cual importaremos wavfile para procesar la señal y así
obtener su información.
2.- Una vez importadas las librerías se procede a utilizarlas, en la línea 13 mediante el método read
leemos el archivo Pajaros_01.wav del cual obtendremos la frecuencia de muestreo y la data del
archivo.
3.- En la línea 14 se procede a hacer el guardado de data en SonidoK.txt
4.- De la línea 15 se imprimirá el valor de la frecuencia de muestreo por consola.
RESULTADOS:
Archivo SonidoK.txt generado
Frecuencia de muestreo presentado en consola:

b) Aplicando la DFT o FFT determinar la respuesta en frecuencia X i [k] de x i [n]. Luego,

analizar y determinar las componentes de frecuencia de interés.

Determinaremos la respuesta en frecuencia de x[n] y luego procederemos a determinar las

componentes de frecuencia de interés, para ello nos apoyaremos en el código escrito en el lenguaje
de programación Python análisis_frecuencia.py (Anexo: Código análisis_frecuencia.py)
Tomaremos el ejemplo anterior y continuaremos el análisis:
1.- Agregaremos una librería más que es la de la línea 10 matplotlib.pyplot la cual nos permitirá
plotear(graficar).
2.- Teniendo el dato de la frecuencia de muestreo lo definimos en la línea 18 como la variable VEL.
3.- Procederemos a calcular la fft de la data obtenida para eso en la línea 21 calcularemos la
longitud de la data obtenida, en la línea 22 calcularemos la fft de la data mediante np.fft.fft, en la
línea 23 que devolverá la frecuencia muestreada de la fft, en la línea 24 dejaremos listos los valores
para la frecuencia en Hz.
4.- Para las gráficas en la línea 28 definiremos 2 subplots mediante plt.subplots(1,2), pasaremos a
definir el primer subploteo cuya gráfica será la señal en el dominio del tiempo y el segundo subplot
será la transformada rápida de Fourier en función de la frecuencia.
RESULTADOS:
Obtuvimos la señal en el dominio del tiempo (subplot izquierdo) y su FFT en dominio de la
frecuencia, pero nos damos cuenta que el audio está siendo muestreado en el canal estéreo por lo
que haremos el cambio a mono para el respectivo análisis, para esto usaremos el código apoyaremos
en el código escrito en el lenguaje de programación Python conversión_a_mono.py (Anexo: Código
conversión_a_mono.py)
Notamos que el código es parecido pero esta vez agregaremos algunas cosas:
1.- En la línea 11 importaremos la librería pydub de la cual importaremos AudioSegment.
2.- En la línea 13 nombraremos la variable sound en representación para leer el archivo
Pajaros_01.wav mediante AudioSegment.from_wav, en la línea 14 mediante el método
set_channels(1) cambiaremos el canal estéreo(2) a mono(1) y luego en la línea 15 crearemos el
archivo Pajaros_011.wav mediante el método export que contendrá el cambio deseado.
3.- Se creará el archivo .wav, en caso de presentarse un error como este en la consola:
Nos dirigimos al directorio en donde está guardado nuestro archivo y cambiaremos el nombre de:

Añadiremos al nombre la extensión .wav luego damos enter:

Generando lo siguiente:

Volvemos a correr y veremos que ahora sí procede el cambio generando así:

Y nos damos cuenta que según el audio en dominio del tiempo es el mismo sin embargo el espectro
en frecuencia se ve modificado por el cambio de canal de estéreo a mono.
Haciendo un zoom en la gráfica de la Transformada rápida de Fourier tomaremos las frecuencias de
interés.
Según esta figura el análisis podemos hacerlo desde 1 KHz hasta 5 KHz y también se genra un
archivo .txt que guardará el cambio correspondiente, dicho archivo lo guardaremos como
SonidoK1.txt
c) Diseñar un filtro pasabanda (IIR o FIR) con frecuencia central y ancho de banda de
acuerdo con los resultados de (b).
Como resultado de esta etapa:

Presentar el modelo matemático del filtro desarrollado y un diagrama de bloques.

figura 1. filtro Butterworth de orden 2.

 figura 2. filtro Butterworth de orden 4.

figura 3. filtro Butterworth de orden 6.

Como podemos apreciar en la figura1 y 2 estos filtros están diseñados con OPAM, y también
podemos apreciar que esta compuesta por etapas de acuerdo con el orden que deseamos
desarrollar. Si queremos desarrollar un filtro Butterworth de manera física nos genera más
costo en componentes cuando desarrollemos de orden superior, por eso nosotros hemos optado
por desarrollar un filtro digital Butterworth de manera computacional en el Software Python de
orden 6 porque nos parece conveniente y óptimo debido a que su pendiente no sea muy
inclinada ni muy pronunciada.

Especificaciones técnicas del filtro.

1. La principal característica que tiene este filtro es el hecho de que la función de módulo (o
atenuación) es máximamente plana en el origen.
2. Si observamos la forma de la función de transferencia veremos que polos y ceros están situados.
3. Cuando estudiemos el resto de las funciones de aproximación de amplitud veremos que,
comparadas con ellas, las funciones de Butterworth presentan el orden más elevado en igualdad de
condiciones impuestas.
4. los costos para el desarrollo de un filtro de orden alto nos conlleva a elevar los costos de manera
que ya no es rentable.

Desarrollo del filtro Butterworth pasa banda en Python.

Para el diseño del filtro tendremos en cuenta las frecuencias de corte inferior en 1 KHz hasta 5 KHz
para la primera prueba, la segunda prueba será de 2 KHz hasta 5 KHz y la tercera prueba será de 2
KHz hasta 4.5 KHz.
Para las pruebas debemos aclarar que grabaremos el audio para filtrar los ruidos del medio por lo
que se usará el siguiente código escrito en Python grabación_y_filtrado.py (Código
grabación_y_filtrado.py)
1.- Comenzaremos importando las librerías, las cuales son, en la línea 8 importamos time para el
ocasionar un delay más adelante, en la línea 9 está pyaudio para el procesado de la grabación, en la
línea 10 estará wave que nos ayudará a crear el archivo.wav donde se guardará el audio, en la línea
11 se usará la librería sounddevice, en la línea 12 se importó wavfile para el procesado de la señal,
en la línea 13 se tiene la librería matplotlib.pyplot que servirá para plotear las gráficas necesarias, en
la línea 14 usaremos la librería numpy para la representación en arreglos, en la línea 15
importaremos freqz, butter y filtfilt, en la línea 16 desde matplotlib importaremos patches.
2.- En la línea 21 dará el mensaje de bienvenida y en la línea 22 se mostrará un mensaje para la
duración en segundos, la línea 23 almacenará el valor numérico entero en la variable tiempo.
3.- Desde la línea 24 hasta la línea 29 se definen los parámetros para la grabación de la señal en la
que se tiene el formato, el canal mono (1) o estéreo (2), la velocidad de muestreo que ya obtuvimos
en el apartado a), los trozos a los cuales será muestreado, la duración que tendrá nuestro audio y el
nombre del archivo con el que será guardado.
4.- En la línea 31 se llama al la librería pyaudio la cual almacenaremos en la variable audio para
iniciar el stream o grabación de acuerdo a los parámetros antes fijados.
5.- Desde la línea 36 hasta la línea 50 se tendrá se procederá a la grabación, para esto crearemos un
arreglo vacío en el cual será almacenada la data, luego tendremos la finalización de la grabación y
se procederá con la creación del archivo en el cual será almacenada la información de acuerdo a los
parámetros antes mencionados.
6.- Desde la línea 53 hasta la línea 58 tendremos el análisis en frecuencia para la señal empezando
por abrir el archivo .wav generado mediante wavfile.read obteniendo así su frecuencia de muestreo
y su data, luego hallaremos su longitud, la fft a la data, la fft a la longitud y luego la multiplicamos
por la frecuencia de muestreo para obtener la frecuencia en Hz.
7.- Para cuestiones del filtro una vez hecho el análisis del apartado b) pondremos las frecuencias
convenientes que se guardarán en las variables corteinf(frecuencia de corte inferior) y
cortesup(frecuencia de corte superior) para el filtro, tomaremos también un orden 6 por condiciones
medias y luego corteinf se guardará en lowcut mientras cortesup se guardará en highcut.
En la línea 70 se define la función butter_passband que nos devolverá los coeficientes a y b,
denominador y numerador del filtro tomando como datos de entrada la frecuencia de corte inferior,
frecuencia de corte superior, frecuencia de muestreo y el orden.
En la línea 78 se define la función butter_bandpass_filter que aplicará el filtro antes definido a la
data para proceder con el filtrado, para esto necesitará los parámetros tales como data, frecuencia de
corte inferior, frecuencia de corte superior, frecuencia de muestreo y orden del filtro, obteniendo así
la función Y filtrada.
8.- En la línea 84 se reemplazan los valores guardados en las variables para proceder con el filtro,
en la línea 86 se obtienen los parámetros w y h, los cuales son los coeficientes para la respuesta en
frecuencia de acuerdo con los coeficientes del filtro diseñado, en la línea 89 se tiene la función Y
que será la aplicación del filtro a la data teniendo los valores guardados en las variables
correspondientes, luego se hallará su fft en la línea 92.
9.- Desde la línea 94 a 99 se tiene la muestra del audio filtrado en el que se tendrá como entrada la
función Y (señal filtrada) en formato int16 y se podrá reproducir mediante la función sd.play, luego
se guardará la señal en el archivo SresultadoK.text
10.- Desde la línea 101 hasta la 154 se tomarán los coeficientes del filtro para la gráfica en el plano
complejo z para la ROC.
11.- Para las gráficas en la línea se empezará por la figura 1 en la que tendrá 2 subplots, una que
representará la señal en función del tiempo y en la segunda se verá la fft en función de la frecuencia,
para la figura 2 se graficará el filtro Butter de sexto orden en función de la frecuencia, en la figura 3
se comparará la señal original y la señal filtrada, ambas en el dominio del tiempo, la figura 4 es la
fft de la señal filtrada y la figura 5 grafica la ROC del filtro una vez obtenidos los coeficientes.
RESULTADOS
Primera muestra.
Para una frecuencia de corte inferior de 1 KHz hasta 5 KHz
Segunda muestra.
Para 2 KHz y 5 KHz:
Tercera muestra.
Para 2 KHz y 4.5 KHz:
d) Aplicar x [n] al filtro desarrollado y el resultado registrarlo y luego convertirlo a tiempo
discreto en formato SresultadoK.txt y seguidamente a tiempo continuo.

Obtendremos el archivo .txt al que llamaremos Sresultado.txt, en la línea 99 del código se generará
el archivo y estará en el mismo directorio en donde se generó el archivo Python.

Concusiones.

 Del análisis de los audios dados para realizar el trabajo hemos podido apreciar que por
defecto viene en modo estéreo y para realizar el trabajo de manera mas cómoda con el
software Python lo pasaremos a canal mono y de ahí podremos hacer el estudio donde
obtuvimos que los FFT de las dos formas tenemos diferencias debido a la acumulación
de la magnitud de frecuencia.
 También hemos podido apreciar de como guardamos en archivos txt. Del software y
así poder analizar los valores discretos que nos arroja el análisis de ello.
  Para el filtro hemos desarrollado 3 de prueba donde vamos a tomar distintos anchos de
banda que iremos desarrollando, apreciando donde está la concentración de
frecuencias y buscar el optimo rango para que la señal grabada se pueda parecer a l de
la grabación.
 Del análisis de los filtros podemos observar que cuando requerimos un orden mayor
vamos a requerir mayor cantidad de componentes que aumentan espacios y costos del
proyecto, lo cual seria una desventaja si se trata de optimizar el filtrado es por ello se
prefiere un filtro IIR a un FIR.

ANEXOS:
Código toma_de_muestras.py

import numpy as np
from scipy.io import wavfile
import matplotlib.pyplot as plt
#fsonido=frecuencia sonido
# INGRESO

fs, data = wavfile.read('Pajaros_01.wav')

np.savetxt('SonidoK.txt', data)
print(fs)

Código análisis_frecuencia.py

import numpy as np
from scipy.io import wavfile
import matplotlib.pyplot as plt
#fsonido=frecuencia sonido
# INGRESO
fs, data = wavfile.read('Pajaros_01.wav')
np.savetxt('SonidoK.txt', data)
print(fs)

VEL=22050#Velocidad de muestreo

#print(fs)
L = len(data)
c = np.fft.fft(data) #FFT a la data.
freq = np.fft.fftfreq(L)#FFT a la longitud para la frecuencia
freq_in_hertz = abs(freq * fs)#Frecuencia en Hz.

#-----------INICIO DE LA
GRÁFICA--------------------------------------------
#Se generan los subplot
fig,(ax1,ax2)=plt.subplots(1,2)

#Se grafica la voz o sonido emitido.

ax1.plot(np.arange(0,L)/VEL,data)
ax1.title.set_text('Audio en dominio del tiempo')
ax1.set_xlabel(' Duración ')#Se tiene la (duración+1)*fs
ax1.set_ylabel(' Data ')#En términos de potencia.
ax1.grid(True)
#Se grafica la Transformada de Fourier del audio.
ax2.plot(freq_in_hertz, abs(c))
ax2.title.set_text('TF del audio')
ax2.set_xlabel(' Frecuencia ')
ax2.set_ylabel(' Mag(FFT) ')
ax2.grid(True)
Código conversión_a_mono.py

from scipy.io import wavfile

import matplotlib.pyplot as plt
import numpy as np
from pydub import AudioSegment

sound = AudioSegment.from_wav("D:/PDS/Pajaros_01.wav")
sound = sound.set_channels(1)
sound.export("Pajaros_011", format("wav"))

VEL=22050#Velocidad de muestreo
archivo="Pajaros_011.wav"#Nombre con el que se guardará el archivo.

#Se extrae la frecuencia de muestreo(fs) y los datos muestreados(data).

fs, data = wavfile.read(archivo)
#print(fs)
L = len(data)
c = np.fft.fft(data) #FFT a la data.
freq = np.fft.fftfreq(L)#FFT a la longitud para la frecuencia
freq_in_hertz = abs(freq * fs)#Frecuencia en Hz.

np.savetxt('SonidoK1.txt', data)

#-----------INICIO DE LA GRÁFICA--------------------------------------------
#Se generan los subplot
fig,(ax1,ax2)=plt.subplots(1,2)

#Se grafica la voz o sonido emitido.

ax1.plot(np.arange(0,L)/VEL,data)
ax1.title.set_text('Audio en dominio del tiempo')
ax1.set_xlabel(' Duración ')#Se tiene la (duración+1)*fs
ax1.set_ylabel(' Data ')#En términos de potencia.
ax1.grid(True)

#Se grafica la Transformada de Fourier del audio.

ax2.plot(freq_in_hertz, abs(c))
ax2.title.set_text('TF del audio')
ax2.set_xlabel(' Frecuencia ')
ax2.set_ylabel(' Mag(FFT) ')
ax2.grid(True)

plt.show()

print("*----------------Gracias por usar mi aplicación-----------------*")

Código grabación_y_filtrado.py

import time
import pyaudio
import wave
import sounddevice as sd
from scipy.io import wavfile
import matplotlib.pyplot as plt
import numpy as np
from scipy.signal import freqz, butter,filtfilt
from matplotlib import patches

print("Bienvenido a su programa de grabación de voz.")

print("Por favor ingrese la duración de su grabacion en segundos:")
tiempo=int(input())
FORMATO=pyaudio.paInt16#Guardado del formato.
CANALES=1#Canales
VEL=22050#Velocidad de muestreo
TROZOS=1024#Trozos
DURACION=tiempo#Tiempo a grabar.
archivo="grabación.wav"#Nombre con el que se guardará el archivo.

audio=pyaudio.PyAudio()
stream=audio.open(format=FORMATO,channels=CANALES,rate=VEL,
input=True,frames_per_buffer=TROZOS)

print("Grabando...")
frames=[]
for i in range(0,int((VEL/TROZOS)*DURACION)):
data=stream.read(TROZOS)
frames.append(data)
print("Grabación terminada")
stream.stop_stream()#Deja de grabar.
stream.close()#Se cierra el stream.
audio.terminate()#Se termina el proceso completo de grabación de audio.
#Se procede a procesar el audio y guardarlo con las características escogidas.
waveFile=wave.open(archivo,'wb')#wb es para ponerlo en modo de solo escritura.
waveFile.setnchannels(CANALES)#Para el número de canales en audio, 1 para mono y 2
para stéreo.
waveFile.setsampwidth(audio.get_sample_size(FORMATO))#Se establece el ancho de
muestras en "n" bits.
waveFile.setframerate(VEL)#Se establece la velocidad de los fotogramas.
waveFile.writeframes(b''.join(frames))#Escribe los cuadros de audio.
waveFile.close()#Se completa el guardado del archivo.

#Se extrae la frecuencia de muestreo(fs) y los datos muestreados(data).

fs, data = wavfile.read('grabación.wav')
#print(fs)
L = len(data)
c = np.fft.fft(data) #FFT a la data.
freq = np.fft.fftfreq(L)#FFT a la longitud para la frecuencia
freq_in_hertz = abs(freq * fs)#Frecuencia en Hz.

print("Por favor ingrese la frecuencia de corte inferior en Hz para el filtro(se recomienda

usar 40 Hz):")
corteinf=int(input())
#40.0
print("Por favor ingrese la frecuencia de corte superior en Hz para el filtro(se recomienda
usar 3000 Hz):")
cortesup=int(input())
#4000
order=6
lowcut=corteinf
highcut=cortesup
#Se define el filtro Butter pasabanda y se consiguen los coeficientes b y a.
def butter_bandpass(lowcut, highcut, fs, order=order):
nyq = 0.5 * fs
low = lowcut / nyq
high = highcut / nyq
b, a = butter(order, [low, high], btype='band',analog=False)
return b, a

#Se define el filtro Butter pasabanda pero ya aplicada a la señal.

def butter_bandpass_filter(data, lowcut, highcut, fs, order=6):
b, a = butter_bandpass(lowcut, highcut, fs, order=order)
y = filtfilt(b, a, data)
return y

#Se guardan los coeficientes del filtro.

b, a = butter_bandpass(lowcut, highcut, fs, order=order)
#Se obtienen los coeficientes para la frecuencia.
w, h = freqz(b, a, worN=44100)

#Se guardan los coeficientes del filtro aplicado a la señal de entrada.

y=butter_bandpass_filter(data, lowcut, highcut, fs, order=6)
#Se calcula la FFT de la señal filtrada.
e = np.fft.fft(y)

print("El audio filtrado se escucha así: ")

time.sleep(2)
xMod = np.real(y).astype(np.int16)
sd.play(xMod,VEL)
sd.wait()
np.savetxt('SresultadoK.txt', y)

def zplane(b,a,filename=None):
"""Plot the complex z-plane given a transfer function.
"""

# get a figure/plot
ax = plt.subplot(111)

# create the unit circle

uc = patches.Circle((0,0), radius=1, fill=False,
color='black', ls='dashed')
ax.add_patch(uc)

# The coefficients are less than 1, normalize the coeficients

if np.max(b) > 1:
kn = np.max(b)
b = b/float(kn)
else:
kn = 1
if np.max(a) > 1:
kd = np.max(a)
a = a/float(kd)
else:
kd = 1

# Get the poles and zeros

p = np.roots(a)
z = np.roots(b)
k = kn/float(kd)

# Plot the zeros and set marker properties

t1 = plt.plot(z.real, z.imag, 'go', ms=10)
plt.setp( t1, markersize=10.0, markeredgewidth=1.0,
markeredgecolor='k', markerfacecolor='g')

# Plot the poles and set marker properties

t2 = plt.plot(p.real, p.imag, 'rx', ms=10)
plt.setp( t2, markersize=12.0, markeredgewidth=3.0,
markeredgecolor='r', markerfacecolor='r')

ax.spines['left'].set_position('center')
ax.spines['bottom'].set_position('center')
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)

# set the ticks

 r = 1.5; plt.axis('scaled'); plt.axis([-r, r, -r, r])
ticks = [-1, -.5, .5, 1]; plt.xticks(ticks); plt.yticks(ticks)

if filename is None:
plt.show()
else:
plt.savefig(filename)
return z, p, k

#------------------------INICIO DE LA GRÁFICA----------------------------------
#Se generan los subplot
fig,(ax1,ax2)=plt.subplots(1,2)

#Se grafica la voz o sonido emitido.

ax1.plot(np.arange(0,L)/VEL,data)
ax1.title.set_text('Audio en dominio del tiempo')
ax1.set_xlabel(' Duración ')#Se tiene la (duración+1)*fs
ax1.set_ylabel(' Data ')#En términos de potencia.
ax1.grid(True)

#Se grafica la Transformada de Fourier del audio.

ax2.plot(freq_in_hertz, abs(c))
ax2.title.set_text('TF del audio')
ax2.set_xlabel(' Frecuencia ')
ax2.set_ylabel(' Mag(FFT) ')
ax2.grid(True)

#Se grafica el filtro que se aplicará.

plt.figure(2)
plt.plot((fs * 0.5 / np.pi) * w, abs(h), label="order = %d" % order)
plt.title('Filtro Butter de 6to orden')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Gain')
plt.grid(True)
plt.legend(loc='best')

#Se comparan las señales de entrada y la filtrada.

plt.figure(3)
plt.plot(np.arange(0,L)/VEL,data,label='Señal original')
plt.plot(np.arange(0,L)/fs, y, label='Señal Filtrada en el dominio del tiempo')
plt.xlabel('time (seconds)')
plt.grid(True)
plt.axis('tight')
plt.legend(loc='upper left')

#TF de la señal filtrada

plt.figure(4)
plt.plot(freq_in_hertz, abs(e))
plt.title('TF del audio filtrado')
plt.xlabel('Frequency (Hz)')
plt.ylabel('TF')
plt.grid(True)
#Para generar una nueva gráfica al iniciar una nueva grabación.
plt.figure(5)
zplane(b, a)
plt.show()
print("*----------------Gracias por usar mi aplicación-----------------*")