def signal_prueba2():
fs = 1000
N = 1000
f01 = 9*fs/N
f02 = 8*fs/N
a0 = np.sqrt(2)
df = fs/N
ff = np.linspace(0, int((N-1)*df), int(N))
m_f01 = int(N*(f01)/fs)
# tt, sen1 = gen.generador_senoidal(fs, f01, int(N/4), a0)
# sen1[int(fs/f01):] = 0
# tt, sen2 = gen.generador_senoidal(fs, f02, int(3*N/4), a0)
# sen2[int(fs/f02):] = 0
tt, sen1 = gen.generador_senoidal(fs, f01, N, a0)
sen1[int(fs/f01):] = 0
spectrum1 = tools.spectrum_analyzer(sen1, fs, N, plot = False)
tt, sen2 = gen.generador_senoidal(fs, f02, N, a0)
sen2[:int(3*fs/f02)] = 0
sen2[int(4*fs/f02):] = 0
spectrum2 = tools.spectrum_analyzer(sen2, fs, N, plot = False)
# tt, sen2 = gen.generador_senoidal(fs, f02, int(3*N/4), a0)
# sen2[int(fs/f02):] = 0
plt.figure()
plt.subplot(2,1,1)
plt.stem(ff[0:int(N//2+1)], 2.0/N * np.abs(spectrum1[0:int(N//2+1)]))
plt.subplot(2,1,2)
plt.stem(ff[0:int(N//2+1)], 2.0/N * np.abs(spectrum2[0:int(N//2+1)]))
def prueba_fase_cuadradas():
fs = 1000
N = 1000
f01 = 9*fs/N
f02 = 8*fs/N
a0 = np.sqrt(2)
df = fs/N
ff = np.linspace(0, int((N-1)*df), int(N))
m_f01 = int(N*(f02)/fs)
cuad1 = np.ones(N)
cuad1[int(fs/f02):] = 0
cuad2 = np.ones(N)
cuad2[:int(fs/f01)] = 0
cuad2[int(2*fs/f01):] = 0
tt = np.linspace(0, (N-1)/fs, N)
plt.figure(figsize = (12, 12))
plt.subplot(2,1,1)
plt.plot(tt, cuad1)
plt.xlabel('Tiempo [seg]')
plt.grid()
plt.ylabel('Amplitud [V]')
plt.title('Cuadrada 1')
plt.subplot(2,1,2)
plt.plot(tt, cuad2)
plt.xlabel('Tiempo [seg]')
plt.grid()
plt.ylabel('Amplitud [V]')
plt.title('Cuadrada 2')
spectrum1 = tools.spectrum_analyzer(cuad1, fs, N, plot = False)
spectrum2 = tools.spectrum_analyzer(cuad2, fs, N, plot = False)
plt.figure(figsize = (12, 12))
plt.subplot(2,1,1)
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum1[0:int(N//2+1)]),np.real(spectrum1[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
# plt.xlim((0,10))
plt.grid()
plt.ylabel('Fase [rad]')
plt.title('Fase de la señal')
plt.subplot(2,1,2)
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum2[0:int(N//2+1)]),np.real(spectrum2[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
# plt.xlim((0,10))
plt.grid()
plt.ylabel('Fase [rad]')
plt.title('Fase de la señal')
def testbench():
fs = 1000
N = 1000
a1 = 1
a2 = pow(10, -2) * a1
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
tt = np.linspace(0, (N - 1) / fs, N)
f01 = fs / 4
f02 = f01 + 10 * fs / (N)
print("La frecuencia 1 es" + str(f01) + " y la frecuencia 2 es " +
str(f02))
x1 = gen.generador_senoidal(fs, f01, N, a1)
x2 = gen.generador_senoidal(fs, f02, N, a2)
signal = x1 + x2
plt.plot(tt, signal)
spectrum = tools.spectrum_analyzer(signal, fs, N, plot=False)
plt.figure()
plt.xlabel('f')
plt.title('Espectro en frecuencia')
plt.plot(
ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)]) +
np.finfo(float).eps))
plt.xlabel('Frecuencia [Hz]')
plt.ylabel('Magnitud [V]')
plt.xlim((156, 356))
plt.grid()
plt.suptitle("Ejercicio 2a")
# El 2b es 300 dB aprox -> puedo bajar 260 dB
signal = signal / np.max(signal)
signal_q = tools.quantizer(signal, 16, 2)
spectrum = tools.spectrum_analyzer(signal_q, fs, N, plot=False)
plt.figure()
plt.xlabel('f')
plt.title('Espectro en frecuencia')
plt.plot(ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)])))
# plt.plot(ff[0:int(N//2+1)], 20*np.log10(2.0/N * np.abs(spectrum[0:int(N//2+1)]) + np.finfo(float).eps))
plt.xlabel('Frecuencia [Hz]')
plt.ylabel('Magnitud [V]')
# plt.xlim((156,356))
plt.grid()
plt.suptitle("Ejercicio 2b - Cuantizado")
def prueba():
fs = 1000
N = 1000
f01 = 9*fs/N
f02 = 8*fs/N
a0 = np.sqrt(2)
df = fs/N
ff = np.linspace(0, int((N-1)*df), int(N))
tt, sen1 = gen.generador_senoidal(fs, f01, int(N/4), a0)
sen1[int(fs/f01):] = 0
tt, sen2 = gen.generador_senoidal(fs, f02, int(3*N/4), a0)
sen2[int(fs/f02):] = 0
signal1 = np.concatenate((sen1, sen2))
tt, sen1 = gen.generador_senoidal(fs, f02, int(N/4), a0)
sen1[int(fs/f02):] = 0
tt, sen2 = gen.generador_senoidal(fs, f01, int(3*N/4), a0)
sen2[int(fs/f01):] = 0
signal2 = np.concatenate((sen1, sen2))
spectrum1 = tools.spectrum_analyzer(signal1, fs, N, plot = False)
spectrum2 = tools.spectrum_analyzer(signal2, fs, N, plot = False)
tt = np.linspace(0, (N-1)/fs, N)
plt.subplot(2,1,1)
plt.plot(tt, signal1)
plt.subplot(2,1,2)
plt.plot(tt, signal2)
plt.figure(figsize = (12, 12))
plt.subplot(2,1,1)
plt.title("Senoidal de " + str(f01) + ' Hz y ' + str(f02) + ' Hz')
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum1[0:int(N//2+1)]),np.real(spectrum1[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((0,20))
plt.grid()
plt.ylabel('Fase [rad]')
plt.subplot(2,1,2)
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum2[0:int(N//2+1)]),np.real(spectrum2[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((0,20))
plt.grid()
plt.ylabel('Fase [rad]')
plt.title("Senoidal de " + str(f02) + ' Hz y ' + str(f01) + ' Hz')
def prueba_fase():
fs = 1000
N = 1000
f01 = 9*fs/N
f02 = 8*fs/N
a0 = np.sqrt(2)
df = fs/N
ff = np.linspace(0, int((N-1)*df), int(N))
m_f01 = int(N*(f01)/fs)
tt, sen1 = gen.generador_senoidal(fs, f01, int(N/4), a0)
sen1[int(fs/f01):] = 0
tt, sen2 = gen.generador_senoidal(fs, f02, int(3*N/4), a0)
sen2[int(fs/f02):] = 0
signal = np.concatenate((sen1, sen2))
tt = np.linspace(0, (N-1)/fs, N)
plt.figure(figsize = (12, 12))
spectrum = tools.spectrum_analyzer(signal, fs, N, plot = False)
plt.subplot(2,1,1)
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum[0:int(N//2+1)]),np.real(spectrum[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((5,10))
plt.grid()
plt.ylabel('Fase [rad]')
plt.title('Fase de la señal')
tt, sen1 = gen.generador_senoidal(fs, f02, int(N/4), a0)
sen1[int(fs/f01):] = 0
tt, sen2 = gen.generador_senoidal(fs, f01, int(3*N/4), a0)
sen2[int(fs/f02):] = 0
signal = np.concatenate((sen1, sen2))
tt = np.linspace(0, (N-1)/fs, N)
spectrum = tools.spectrum_analyzer(signal, fs, N, plot = False)
plt.subplot(2,1,2)
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum[0:int(N//2+1)]),np.real(spectrum[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((5,10))
plt.grid()
plt.ylabel('Fase [rad]')
plt.title('Fase de la señal')
def testbench():
fs = 1000
N = 1000
a0 = 1
f0 = 10
tiempo, señal1 = gen.generador_senoidal(fs, f0, N, a0)
tools.spectrum_analyzer(señal1, fs, N)
tiempo, señal2 = gen.generador_ruido(fs, N, mean = 0, variance = 5)
tools.spectrum_analyzer(señal2, fs, N)
tiempo, señal3 = gen.generador_ruido(fs, N, distribution = 'Uniform', high = 2, low = -2)
tools.spectrum_analyzer(señal3, fs, N)
tiempo, señal4 = gen.generador_ruido(fs, N, distribution = 'Triangular')
tools.spectrum_analyzer(señal4, fs, N)
plt.figure()
plt.subplot(4,1,1)
plt.hist(señal1, bins=10) # arguments are passed to np.histogram
plt.subplot(4,1,2)
plt.hist(señal2, bins=10) # arguments are passed to np.histogram
plt.subplot(4,1,3)
plt.hist(señal3, bins=10) # arguments are passed to np.histogram
plt.subplot(4,1,4)
plt.hist(señal4, bins=10) # arguments are passed to np.histogram
def testbench():
fs = 1200
N = 1200
f0 = 170
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
tt = np.linspace(0, (N - 1) / fs, N)
signal = gen.generador_cuadrada(1, f0, fs, N, 0.5)
plt.figure()
plt.plot(tt, signal)
tools.spectrum_analyzer(signal, fs, N)
def zero_padding_testbench():
fs = 1000 # Frecuencia de muestreo
L = 1000 # Cantidad de muestras
resultados = []
frecuencias = []
M = (0, L / 10, L, 10 * L) # Cantidad de ceros que se agregan
fd = (0, 0.01, 0.25, 0.5) # Offsets respecto al bin
f0 = fs / 4 + fd[0] # Frecuencia de la señal
for zero_padding in M:
tt, sen = gen.generador_senoidal(fs, f0, L)
signal = np.concatenate((sen, np.zeros(int(zero_padding))))
N = L + zero_padding
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
spectrum = tools.spectrum_analyzer(signal, fs, N, plot=False)
resultados.append(2.0 / (L) * np.abs(spectrum[0:int((N) // 2 + 1)]))
frecuencias.append(ff[0:int((N) // 2 + 1)])
for res, freq, i, zp in zip(resultados, frecuencias, range(1, 5), M):
plt.subplot(2, 2, i)
plt.title('zero padding de ' + str(zp) + ' ceros')
plt.stem(freq, res)
plt.xlim((225, 275))
plt.suptitle('Senoidal de ' + str(f0) + ' Hz', fontsize=16)
def testbench():
fs = 1024
N = 1024
prueba = (10, 100, 1000, 10000)
ruidos = []
power_density = []
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
variance = 2
for realizaciones in prueba:
power_density = []
ruidos = []
for i in range(realizaciones):
aux = gen.generador_ruido(fs, N, mean=0, variance=variance)
spec_aux = tools.spectrum_analyzer(aux, fs, N, plot=False)
power_density.append(tools.energy_2(spec_aux))
ruidos.append(aux)
print("Con " + str(realizaciones) + " realizaciones la energía es " +
str(np.average(power_density)))
def parseval_testbench():
fs = 1024 # Frecuencia de muestreo
N = 1024 # Cantidad de muestras
a0 = np.sqrt(2) # Amplitud de la senoidal
f0 = 10 # Frecuencia de la senoidal
energia_n = 0
energia_f = 0
df = fs/N # Resolucion espectral
ff = np.linspace(0, int((N-1)*df), int(N))
tt, s = gen.generador_senoidal(fs, f0, N, a0)
spectrum = tools.spectrum_analyzer(s, fs, N, plot = False)
for x in s:
energia_n = energia_n + pow(x, 2)/N
for i in range(N//2+1):
energia_f = energia_f + pow(2.0/N * np.abs(spectrum[i]), 2)/2
print('Energia antes de la DFT ' + str(energia_n))
print('Energia despues de la DFT ' + str(energia_f))
print(np.sqrt(np.mean(np.square(s))))
def signal_4():
fs = 1000
N = 1000
f01 = 9*fs/N
f02 = 8*fs/N
a0 = np.sqrt(2)
df = fs/N
ff = np.linspace(0, int((N-1)*df), int(N))
m_f01 = int(N*(f01)/fs)
tt, sen1 = gen.generador_senoidal(fs, f01, int(N/4), a0)
sen1[int(fs/f01):] = 0
tt, sen2 = gen.generador_senoidal(fs, f02, int(3*N/4), a0)
sen2[int(fs/f02):] = 0
signal = np.concatenate((sen1, sen2))
tt = np.linspace(0, (N-1)/fs, N)
plt.figure(figsize = (12, 12))
plt.subplot(3,1,1)
plt.plot(tt, signal, label = str(f01) + " Hz y " + str(f02) + ' Hz')
plt.grid()
plt.xlabel('Tiempo [segundos]')
plt.ylabel('Amplitud [V]')
plt.title('Señal en el tiempo')
axes_hdl = plt.gca() # Tomo el objeto axes (Lugar donde se grafica)
axes_hdl.legend(loc='upper right')
spectrum = tools.spectrum_analyzer(signal, fs, N, plot = False)
plt.subplot(3,1,2)
plt.stem(ff[0:int(N//2+1)], 2.0/N * np.abs(spectrum[0:int(N//2+1)]))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((0,100))
plt.grid()
plt.ylabel('Magnitud [V]')
plt.title('Espectro de la señal')
plt.subplot(3,1,3)
plt.stem(ff[0:int(N//2+1)], np.arctan2(np.imag(spectrum[0:int(N//2+1)]),np.real(spectrum[0:int(N//2+1)])))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((0,100))
plt.grid()
plt.ylabel('Magnitud [V]')
plt.title('Espectro de la señal')
energia_total = tools.energy(spectrum)
energia_f0 = pow(2.0/N * np.abs(spectrum[m_f01]),2)/2
imax = np.where(np.abs(spectrum[0:int(N//2+1)]) == np.max(np.abs(spectrum[0:int(N//2+1)])))
print(imax)
print(ff[imax])
print('La energia total es ' + str(energia_total))
print('La energia en f0 es ' + str(energia_f0))
def testbench():
fs = 1000
# para listar las variables que hay en el archivo
#io.whosmat('ECG_TP4.mat')
mat_struct = sio.loadmat('./ECG_TP4.mat')
ecg_one_lead = vertical_flaten(mat_struct['ecg_lead'])
N = len(ecg_one_lead)
ecg_one_lead = ecg_one_lead.reshape(N)
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
x = ecg_one_lead[303600:306000]
plt.plot(x)
tools.spectrum_analyzer(x, fs, len(x))
def cuantizador_testbench():
fs = 1000
N = 1000
a0 = 1
f0 = 10
cantidad_bits = (4, 8, 16)
rango = 2
energia_total_q = []
energia_total_e = []
errores = []
noise_amp = a0 / 10
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
tt, s = gen.generador_senoidal(fs, f0, N, a0)
tt, n = gen.generador_ruido(fs,
N,
low=-noise_amp,
high=noise_amp,
distribution='Uniform')
s_real = s + n
# energia_total = tools.energy(tools.spectrum_analyzer(s_real, fs, N, plot = False))
for b in cantidad_bits:
s_q, sr2 = tools.quantizer_2(s_real, b)
spectrum = tools.spectrum_analyzer(s_q, fs, N, plot=False)
plt.figure()
plt.suptitle("Cuantificador de " + str(b) + ' bits')
plt.subplot(3, 1, 1)
plt.plot(tt, sr2, tt, s_real)
plt.subplot(3, 1, 2)
plt.plot(ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)])))
e = s_q - sr2
plt.subplot(3, 1, 3)
plt.plot(tt, e)
errores.append(e)
# energia_total_q.append(tools.energy(tools.spectrum_analyzer(s_q, fs, N, plot = False)))
# energia_total_e.append(tools.energy(tools.spectrum_analyzer(e, fs, N, plot = False)))
# print(energia_total)
# print(energia_total_q)
# print(energia_total_e)
# plt.figure()
# plt.plot(tt, errores[0])
for error, b in zip(errores, cantidad_bits):
plt.figure(figsize=(12, 6))
plt.title('Cuantizador de ' + str(b) + ' bits')
plt.hist(error, bins=10)
def testbench():
fs = 1024
N = 1024
a0 = 2
f0 = fs / 4
estimador_a0 = []
estimador_a1 = []
m_f0 = int(N * (f0) / fs)
a = m_f0 - 2
b = m_f0 + 2
df = fs / N
tt, fr = gen.generador_ruido(fs,
200,
low=-2,
high=2,
distribution='Uniform')
# window = signal.flattop(N)
for freq in fr:
f1 = f0 + freq * df
sig = gen.generador_senoidal(fs, f1, N, a0)
# spectrum = tools.spectrum_analyzer(sig*window, fs, N, plot = False)
spectrum = tools.spectrum_analyzer(sig, fs, N, plot=False)
estimador_a0.append(np.abs(2.0 / N * spectrum[m_f0]))
estimador_a1.append(tools.rms(2.0 / N * np.abs(spectrum[a:b])))
valor_esperado0 = np.average(estimador_a0)
sesgo0 = valor_esperado0 - a0
varianza0 = np.var(estimador_a0)
plt.figure()
plt.subplot(2, 1, 1)
plt.title("Estimador a0")
plt.xlim((0, 2))
plt.hist(estimador_a0, bins=10)
print("El sesgo de a0 es " + str(sesgo0))
print("La varianza de a0 es " + str(varianza0))
valor_esperado1 = np.average(estimador_a1)
sesgo1 = valor_esperado1 - a0
varianza1 = np.var(estimador_a1)
plt.subplot(2, 1, 2)
plt.title("Estimador a1")
plt.xlim((0, 2))
plt.hist(estimador_a1, bins=10)
print("El sesgo de a1 es " + str(sesgo1))
print("La varianza de a1 es " + str(varianza1))
def leakage_testbench():
fd = (0, 0.01, 0.25, 0.5)
N = 1000 # muestras
fs = 1000 # Hz
f0 = fs / 4
resultados = np.array([], dtype=np.float).reshape(N, 0)
resto_frecuencias = []
frecuencia = 0
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
for i in range(len(fd)):
resto_frecuencias.append(0)
for freq_offset in fd:
tt, signal = gen.generador_senoidal(fs, f0 + freq_offset, N)
spectrum = tools.spectrum_analyzer(signal, fs, N)
resultados = np.hstack([resultados, spectrum.reshape(N, 1)])
m_f0 = int((f0) / df)
# print(2.0/N *np.abs(resultados[m_f0,0]))
# print(2.0/N *np.abs(resultados[m_f0,1]))
# print(2.0/N *np.abs(resultados[m_f0,2]))
# print(2.0/N *np.abs(resultados[m_f0,3]))
# print(2.0/N *np.abs(resultados[m_f0+1,0]))
# print(2.0/N *np.abs(resultados[m_f0+1,1]))
# print(2.0/N *np.abs(resultados[m_f0+1,2]))
# print(2.0/N *np.abs(resultados[m_f0+1,3]))
for freq in ff[0:(N // 2 - 1)]:
if freq != f0:
for i in range(len(fd)):
resto_frecuencias[i] = resto_frecuencias[i] + pow(
(2.0 / N * np.abs(resultados[int(freq), i])), 2)
# print(resto_frecuencias)
for f in ff:
frecuencia = f * (2.0 / N * np.abs(spectrum[int(f)]))
print(frecuencia)
def signal_3():
fs = 1000
N = 1000
f0 = 9*fs/N
a0 = np.sqrt(2)
df = fs/N
ff = np.linspace(0, int((N-1)*df), int(N))
m_f0 = int(N*(f0)/fs)
tt, signal = gen.generador_senoidal(fs, f0, N, a0)
signal[:int(2*fs/f0)+1] = 0
signal[int(3*fs/f0):] = 0
plt.figure(figsize = (12, 12))
plt.subplot(2,1,1)
plt.plot(tt, signal, label = str(f0) + " Hz")
plt.grid()
plt.xlabel('Tiempo [segundos]')
plt.ylabel('Amplitud [V]')
plt.title('Señal en el tiempo')
axes_hdl = plt.gca() # Tomo el objeto axes (Lugar donde se grafica)
axes_hdl.legend(loc='upper right')
spectrum = tools.spectrum_analyzer(signal, fs, N, plot = False)
plt.subplot(2,1,2)
plt.stem(ff[0:int(N//2+1)], 2.0/N * np.abs(spectrum[0:int(N//2+1)]))
plt.xlabel('Frecuencia [Hz]')
plt.xlim((0,100))
plt.grid()
plt.ylabel('Magnitud [V]')
plt.title('Espectro de la señal')
energia_total = tools.energy(spectrum)
energia_f0 = pow(2.0/N * np.abs(spectrum[m_f0]),2)/2
imax = np.where(np.abs(spectrum[0:int(N//2+1)]) == np.max(np.abs(spectrum[0:int(N//2+1)])))
print(imax)
print(ff[imax])
print('La energia total es ' + str(energia_total))
print('La energia en f0 es ' + str(energia_f0))
def testbench():
fs = 1024
N = 1024
realizaciones = 200
# guardaremos las señales creadas al ir poblando la siguiente matriz vacía
power_densities = np.array([], dtype=np.float).reshape(N, 0)
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
variance = 2
for i in range(realizaciones):
aux = gen.generador_ruido(fs, N, mean=0, variance=variance)
spec_aux = tools.spectrum_analyzer(aux, fs, N, plot=False)
psd = pow(1 / N * np.abs(spec_aux), 2)
power_densities = np.hstack([power_densities, psd.reshape(N, 1)])
psd_promedio = np.mean(power_densities, axis=1)
plt.plot(ff[0:int(N // 2 + 1)], 2.0 * psd_promedio[0:int(N // 2 + 1)])
print(np.sum(psd_promedio))
def cuantizador_testbench():
fs = 1000 # Frecuencia de muestreo
N = 1000 # Cantidad de muestras
a0 = np.sqrt(2) # Amplitud de la senoidal
f0 = 10 # Frecuencia de la senoidal
cantidad_bits = (4, 8, 16) # Cantidad de bits de los cuantizadores
rango = 2 # Rango del cuantizador
energia_total_q = [
] # Lista donde guardo la energia total de la señal cuantizada
energia_total_e = [] # Lista donde guardo la energia total del error
errores = [] # Lista donde guardo los errores
signals_q = [] # Lista donde guardo las señales cuantizadas
df = fs / N # Resolucion espectral
ff = np.linspace(0, int((N - 1) * df), int(N))
tt, s = gen.generador_senoidal(fs, f0, N, a0)
tt, n = gen.generador_ruido(fs,
N,
mean=0,
variance=0.1,
distribution='Normal')
print("La energia de la señal es " + str(tools.energy(s, domain='time')))
print("La energia del ruido es " + str(tools.energy(n, domain='time')))
s_real = s + n
# Normalizo en amplitud para que no sature el cuantizador
s_real = s_real / np.max(np.abs(s_real))
s = s / np.max(np.abs(s))
energia_total = tools.energy(
tools.spectrum_analyzer(s_real, fs, N, plot=False))
for b in cantidad_bits:
s_q = tools.quantizer(s, b, rango)
spectrum = tools.spectrum_analyzer(s_q, fs, N, plot=False)
e = s_q - s
signals_q.append(s_q)
errores.append(e)
energia_total_q.append(
tools.energy(tools.spectrum_analyzer(s_q, fs, N, plot=False)))
energia_total_e.append(
tools.energy(tools.spectrum_analyzer(e, fs, N, plot=False)))
plt.figure()
plt.suptitle("Cuantificador de " + str(b) + ' bits con q = ' +
str(rango / (pow(2, b) - 2)))
plt.subplot(3, 1, 1)
plt.xlabel('Tiempo [Seg]')
plt.ylabel('Amplitud [V]')
plt.xlim(0, 0.1)
plt.stem(tt, s_q, 'b', label=r'Señal cuantizada')
plt.hold
plt.plot(tt, s, 'r', label=r'Señal real')
plt.legend()
plt.subplot(3, 1, 2)
plt.xlabel('Frecuencia [Hz]')
plt.ylabel('Magnitud [dB]')
plt.plot(ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)])))
plt.subplot(3, 1, 3)
e_normalizado = e / (rango / (pow(2, b) - 2))
plt.hist(e_normalizado, bins=15)
for b in cantidad_bits:
s_q = tools.quantizer(s_real, b, rango)
spectrum = tools.spectrum_analyzer(s_q, fs, N, plot=False)
e = s_q - s_real
signals_q.append(s_q)
errores.append(e)
energia_total_q.append(
tools.energy(tools.spectrum_analyzer(s_q, fs, N, plot=False)))
energia_total_e.append(
tools.energy(tools.spectrum_analyzer(e, fs, N, plot=False)))
plt.figure()
plt.suptitle("Cuantificador de " + str(b) + ' bits con q = ' +
str(rango / (pow(2, b) - 2)))
plt.subplot(3, 1, 1)
plt.xlabel('Tiempo [Seg]')
plt.ylabel('Amplitud [V]')
plt.xlim(0, 0.1)
plt.stem(tt, s_q, 'b', label=r'Señal cuantizada')
plt.hold
plt.plot(tt, s_real, 'r', label=r'Señal real')
plt.legend()
plt.subplot(3, 1, 2)
plt.xlabel('Frecuencia [Hz]')
plt.ylabel('Magnitud [dB]')
plt.plot(ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)])))
plt.subplot(3, 1, 3)
e_normalizado = e / (rango / (pow(2, b) - 2))
plt.hist(e_normalizado, bins=15)
def testbench():
fs = 1000
N = 1000
tt = np.linspace(0, (N - 1) / fs, N)
df = fs / N
ff = np.linspace(0, int((N - 1) * df), int(N))
# Se agregan padding*N ceros para visualizar mejor el espectro de la ventana
padding = 4
df_padding = fs / (padding * N)
ff_padding = np.linspace(0, ((padding * N - 1) * df_padding),
int(padding * N))
ventanas = []
ventanas_label = []
# Generacion de señales
ventanas.append(barlett(N))
ventanas_label.append('Barlett')
ventanas.append(hann(N))
ventanas_label.append('Hann')
ventanas.append(blackman(N))
ventanas_label.append('Blackman')
ventanas.append(flat_top(N))
ventanas_label.append('Flat Top')
for ven, label in zip(ventanas, ventanas_label):
sig = np.concatenate((ven, np.zeros((padding - 1) * N)))
spectrum = tools.spectrum_analyzer(sig, fs, padding * N, plot=False)
fc = np.where(
(np.abs(spectrum[0:int(N // 2 + 1)]) /
np.max(np.abs(spectrum[0:int(N // 2 + 1)]))) < (np.sqrt(2) / 2))
# fc = np.where(20*np.log10(np.abs(spectrum[0:int(N//2+1)])/np.max(spectrum[0:int(N//2+1)]) + np.finfo(float).eps) < -3)
print("La frecuencia de corte de " + label + " es " +
str(ff_padding[fc[0][0]]) + " Hz")
cero = np.where((np.abs(spectrum[0:int(N // 2 + 1)]) /
np.max(np.abs(spectrum[0:int(N // 2 + 1)]))) < 0.001)
print(str(ff_padding[cero[0][0]]))
maximo = 20 * np.log10(
np.max(np.abs(spectrum[cero[0][0]:int(N // 2 + 1)])) /
np.max(np.abs(spectrum[0:int(N // 2 + 1)])) + np.finfo(float).eps)
print(maximo)
plt.figure()
plt.grid()
plt.suptitle('Ventana de ' + label)
plt.subplot(2, 1, 1)
plt.plot(tt, ven)
plt.title('Ventana en el tiempo')
plt.xlabel('Magnitud [V]')
plt.ylabel('Tiempo [Seg]')
plt.subplot(2, 1, 2)
plt.stem(
ff_padding[0:int((padding * N) // 2 + 1)],
2.0 / (N) * np.abs(spectrum[0:int((padding * N) // 2 + 1)]) /
(2.0 / (N) * np.max(np.abs(spectrum))))
plt.title('Espectro de la ventana')
plt.xlim(-1, 20)
plt.xlabel('Magnitud [V]')
plt.ylabel('Frecuencia [Hz]')
def cuantizador_testbench():
fs = 1000 # Frecuencia de muestreo
N = 1000 # Cantidad de muestras
a0 = np.sqrt(2) # Amplitud de la senoidal
f0 = 5 # Frecuencia de la senoidal
cantidad_bits = (4, 8, 16) # Cantidad de bits de los cuantizadores
rango = 2 # Rango del cuantizador
energia_total_q_real = [
] # Lista donde guardo la energia total de la señal cuantizada real
energia_total_q = [
] # Lista donde guardo la energia total de la señal cuantizada ideal
energia_total_e_real = [
] # Lista donde guardo la energia total del error de la señal real
energia_total_e = [
] # Lista donde guardo la energia total del error de la señal ideal
errores_real = [] # Lista donde guardo los errores de la señal real
errores = [] # Lista donde guardo los errores de la señal ideal
signals_q_real = [] # Lista donde guardo las señales cuantizadas reales
signals_q = [] # Lista donde guardo las señales cuantizadas ideales
df = fs / N # Resolucion espectral
ff = np.linspace(0, int((N - 1) * df), int(N))
tt, s = gen.generador_senoidal(fs, f0, N, a0)
tt, n = gen.generador_ruido(fs,
N,
mean=0,
variance=0.1,
distribution='Normal')
s_real = s + n
# Normalizo en amplitud para que no sature el cuantizador
s_real = s_real / np.max(np.abs(s_real))
s = s / np.max(np.abs(s))
energia_total = tools.energy(
tools.spectrum_analyzer(s_real, fs, N, plot=False))
for b in cantidad_bits:
# Cuantizacion de señal ideal
s_q = tools.quantizer(s, b, rango)
signals_q.append(s_q)
energia_total_q.append(
tools.energy(tools.spectrum_analyzer(s_q, fs, N, plot=False)))
e = s_q - s
errores.append(e)
energia_total_e.append(
tools.energy(tools.spectrum_analyzer(e, fs, N, plot=False)))
# Cuantizacion de señal real
s_q = tools.quantizer(s_real, b, rango)
signals_q_real.append(s_q)
e = s_q - s_real
errores_real.append(e)
energia_total_q_real.append(
tools.energy(tools.spectrum_analyzer(s_q, fs, N, plot=False)))
energia_total_e_real.append(
tools.energy(tools.spectrum_analyzer(e, fs, N, plot=False)))
# Ploteo de señales
for b, i in zip(cantidad_bits, range(3)):
plt.figure()
plt.suptitle("Señal de error con cuantificador de " + str(b) +
' bits con q = ' + str(rango / (pow(2, b) - 2)))
# Ploteo de la señal de error ideal
plt.subplot(1, 2, 1)
plt.title("Error de señal ideal (sin ruido)")
plt.xlabel('Tiempo [Seg]')
plt.ylabel('Amplitud [V]')
plt.xlim(0, 0.4)
plt.grid()
plt.plot(tt, errores[i])
# Ploteo de la señal de error real
plt.subplot(1, 2, 2)
plt.title("Error de señal real")
plt.xlabel('Tiempo [Seg]')
plt.ylabel('Amplitud [V]')
plt.xlim(0, 0.4)
plt.grid()
plt.plot(tt, errores_real[i])
# Ploteo de espectros
for b, i in zip(cantidad_bits, range(3)):
plt.figure()
plt.suptitle("Espectro de error con cuantificador de " + str(b) +
' bits con q = ' + str(rango / (pow(2, b) - 2)))
# Ploteo del espectro ideal
plt.subplot(1, 2, 1)
plt.title("Error de señal ideal")
plt.xlabel('Frecuencia [Hz]')
plt.ylabel('Magnitud [dB]')
plt.xlim(0, 100)
plt.grid()
spectrum = tools.spectrum_analyzer(errores[i], fs, N, plot=False)
plt.plot(ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)])))
# Ploteo del espectro real
plt.subplot(1, 2, 2)
plt.title("Error de señal real")
plt.xlabel('Frecuencia [Hz]')
plt.ylabel('Magnitud [dB]')
plt.xlim(0, 100)
plt.grid()
spectrum = tools.spectrum_analyzer(errores_real[i], fs, N, plot=False)
plt.plot(ff[0:int(N // 2 + 1)],
20 * np.log10(2.0 / N * np.abs(spectrum[0:int(N // 2 + 1)])))
for b, i in zip(cantidad_bits, range(3)):
plt.figure()
plt.suptitle("Histograma del error con cuantificador de " + str(b) +
' bits con q = ' + str(rango / (pow(2, b) - 2)))
# Histograma la señal de error ideal
plt.subplot(1, 2, 1)
plt.title("Histograma señal ideal (sin ruido)")
plt.xlabel('Cuentas')
e_normalizado = errores[i] / (rango / (pow(2, b) - 2))
plt.hist(e_normalizado, bins=10)
# Histograma de la señal de error real
plt.subplot(1, 2, 2)
plt.title("Histograma señal real")
plt.xlabel('Cuentas')
plt.ylabel('Veces')
e_normalizado = errores_real[i] / (rango / (pow(2, b) - 2))
plt.hist(e_normalizado, bins=10)
