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