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 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
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():
#%% Definicion de los parametros
frecuencias = (10, 20, 30, 40, 50)
amplitudes = (1, 1, 1, 1, 1)
fases = (0, 0, 0, 0, 0)
fs = 8000
N = 8000
# guardaremos las señales creadas al ir poblando la siguiente matriz vacía
resultados = np.array([], dtype=np.float).reshape(N, 0)
#%% Creacion de las señales
for amp, freq, fase in zip(amplitudes, frecuencias, fases):
tt, signal = gen.generador_senoidal(fs, freq, N, amp, fase)
resultados = np.hstack(
[resultados, signal.reshape(N, 1)]
) # No entiendo porque hay que hacer el reshape. Pasa de (N,) a (N,1) dimensiones
#%% Presentación gráfica de los resultados
plt.figure(1)
line_hdls = plt.plot(tt, resultados)
plt.title('Senoidales')
plt.xlabel('Tiempo [segundos]')
plt.ylabel('Amplitud [V]')
plt.legend(frecuencias, loc='upper right')
plt.show()
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 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 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 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 testbench():
fs = 500
N = 500
a0 = 1
f0 = 10
df = fs/N
ff = np.linspace(0, int(fs/2), int(N/2 + 1))
tiempo, señal = gen.generador_senoidal(fs, f0, N, a0)
Y = dft(señal)
plt.subplot(2,1,1)
plt.plot(tiempo, señal)
plt.subplot(2,1,2)
plt.plot(ff, np.abs(Y))
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 = 1000
R = 1
N = 1000 # Cantidad de muestras
df = fs / N
ff = np.linspace(0, ((N - 1) * df), int(N))
f0 = fs / 4
a1 = 1
att = -3
mean = 0
variance = ((a1**2) / 2) * 10**(att / 10) * N
# variance = 2
for i in range(R):
fr = gen.generador_ruido(fs,
N,
low=-1 / 2,
high=1 / 2,
distribution='Uniform')
noise = np.random.normal(mean, np.sqrt(variance), N)
f1 = f0
signal = gen.generador_senoidal(fs, f1, N, a1) + noise
spectrum = fft(signal, axis=0)
psd = pow((1 / N) * np.abs(spectrum), 2)
plt.figure()
plt.plot(ff[0:int(N // 2 + 1)],
10 * np.log10(np.abs(psd[0:int(N // 2 + 1)]) / np.max((psd))))
# plt.plot(ff[0:int(N//2+1)], 10*np.log10(np.abs(spectrum[0:int(N//2+1)])/np.max(np.abs(spectrum))))
plt.grid()
def testbench():
fs = 1024
N = 1024
a0 = 2
f0 = fs / 4
cantidad_realizaciones = 200
estimador_a0 = []
estimador_a1 = []
m_f0 = int(N * (f0) / fs)
a = m_f0 - 2
b = m_f0 + 2
df = fs / N
fr = gen.generador_ruido(fs,
cantidad_realizaciones,
low=-2,
high=2,
distribution='Uniform')
f1 = f0 + fr
signals = gen.generador_senoidal(fs, f1, N, a0)
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)
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
R = 200 # Cantidad de realizaciones
K = 10 # Cantidad de bloques
N = 1000 # Cantidad de muestras
overlap = 50 # Overlap en %
L = int(N / K) # Cantidad de muestras por bloque
D = int(L * overlap / 100) # Offset de los bloques
cant_promedios = 1 + int((N - L) / D) # Cantidad de promedios realizados
freqs = np.array([], dtype=np.float).reshape(R, 0)
freqs_BT = np.array([], dtype=np.float).reshape(R, 0)
df = fs / L
ff = np.linspace(0, ((L - 1) * df), int(L))
f0 = fs / 4
a1 = 2
SNR = np.array([3, 10], dtype=np.float)
mean = 0
window = barlett(L)
window = window / LA.norm(window)
for snr in SNR:
variance = N * pow(a1, 2) * pow(10, (-snr) / 10) / 2
aux = np.array([], dtype=np.float)
aux2 = np.array([], dtype=np.float)
for i in range(R):
fr = gen.generador_ruido(fs,
N,
low=-1 / 2,
high=1 / 2,
distribution='Uniform')
noise = gen.generador_ruido(fs,
N,
mean,
variance,
distribution='Normal')
f1 = f0 + fr
signal = gen.generador_senoidal(fs, f1, N, a1) + noise
n1 = 0
psd_average = 0
for i in range(cant_promedios):
noise_spectrum = fft(signal[n1:(n1 + L)] * window, axis=0)
psd = pow((1 / L) * np.abs(noise_spectrum), 2)
psd_average = psd_average + psd / cant_promedios
n1 = n1 + D
psd_average = psd_average * L # NO TENGO IDEA DE DONDE SALE ESTE *L
psd_BT = sp.CORRELOGRAMPSD(signal,
NFFT=L,
lag=int(np.round(L / 5)),
window='hamming')
# plt.figure()
# plt.stem(ff[0:int(L//2+1)], psd_BT[0:int(L//2+1)])
indice = np.where(
psd_average[0:int(L // 2 +
1)] == np.max(psd_average[0:int(L // 2 +
1)]))
aux = np.append(aux, ff[indice])
indice = np.where(
psd_BT[0:int(L // 2 + 1)] == np.max(psd_BT[0:int(L // 2 + 1)]))
aux2 = np.append(aux2, ff[indice])
# plt.figure()
# plt.stem(ff[0:int(L//2+1)], psd_average[0:int(L//2+1)])
freqs = np.hstack([freqs, aux.reshape(R, 1)])
freqs_BT = np.hstack([freqs_BT, aux2.reshape(R, 1)])
var = np.var(freqs, axis=0)
var_BT = np.var(freqs_BT, axis=0)
plt.figure()
plt.subplot(2, 1, 1)
plt.hist(freqs[:, 0], bins=11)
plt.title("Histograma de welch con SNR: 3dB")
plt.xlabel("Frecuencia [Hz]")
plt.ylabel("Veces")
plt.grid()
plt.subplot(2, 1, 2)
plt.hist(freqs[:, 1], bins=11)
plt.title("Histograma de welch con SNR: 10dB")
plt.xlabel("Frecuencia [Hz]")
plt.ylabel("Veces")
plt.grid()
plt.figure()
plt.subplot(2, 1, 1)
plt.hist(freqs_BT[:, 0], bins=11)
plt.title("Histograma de BT con SNR: 3dB")
plt.xlabel("Frecuencia [Hz]")
plt.ylabel("Veces")
plt.grid()
plt.subplot(2, 1, 2)
plt.hist(freqs_BT[:, 1], bins=11)
plt.title("Histograma de BT con SNR: 10dB")
plt.xlabel("Frecuencia [Hz]")
plt.ylabel("Veces")
plt.grid()
print("La varianza de welch con SNR 3dB es: " + str(var[0]))
print("La varianza de welch con SNR 10dB es: " + str(var[1]))
print("La varianza de BT con SNR 3dB es: " + str(var_BT[0]))
print("La varianza de BT con SNR 10dB es: " + str(var_BT[1]))
