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)