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 = 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 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 = 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 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
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]))
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)