def pulso(self, K=10, alfa=0.3, num=4, tipo='square'): if (tipo == 'square'): lo = np.ceil(K / 2) - 1 return np.ones(K), lo if (tipo == 'sinc'): n = np.arange(-K * num, K * num + 1, 1) n[n == 0] = -1000 tmp = np.sin(np.pi * n / K) / (np.pi * n / K) lo = np.ceil(len(tmp) / 2) - 1 n[n == -1000] = 0 tmp[n == 0] = 1 return tmp, lo if (tipo == 'squareRZ'): lo = np.ceil(K / 2) - 1 n = np.linspace(0, K - 1, K) x = np.ones_like(n) x[n >= K / 2] = 0 return x, lo if (tipo == 'Manchester'): lo = np.ceil(K / 2) - 1 n = np.linspace(0, K - 1, K) x = np.ones_like(n) x[n >= K / 2] = -1 return x, lo if (tipo == 'RC'): n, v = rcosfilter(num * K, alfa, 1, K) lo = np.ceil(len(v) / 2) return v, lo if (tipo == 'rootRC'): n, v = rrcosfilter(num * K, alfa, 1, K) lo = np.ceil(len(v) / 2) return v, lo
def main(): #generacion random x_re = np.random.randint(0, 2, LEN_SIGNALX) * 2 - 1 x_im = np.random.randint(0, 2, LEN_SIGNALX) * 2 - 1 x_signal = zip(x_re, x_im) #upsample len_upsampled = UPSAMPLE * LEN_SIGNALX up_x_re = np.zeros(len_upsampled) up_x_re[np.array(range(LEN_SIGNALX)) * UPSAMPLE] = x_re up_x_im = np.zeros(len_upsampled) up_x_im[np.array(range(LEN_SIGNALX)) * UPSAMPLE] = x_im #rrcos filter rrcos = rrcosfilter(NBAUDS * UPSAMPLE, ROLL_OFF, 1. / BAUD_RATE, SAMPLE_RATE)[1] rrcos = rrcos / np.sqrt(UPSAMPLE) H, A, F = resp_freq(rrcos, 1. / BAUD_RATE, 256) plt.figure() plt.grid() plt.title('root raised cosine') plt.plot(rrcos) plt.figure() plt.grid() plt.semilogx(F, 20 * np.log(H)) #senial enviada tx_re = np.convolve(up_x_re, rrcos, 'same') tx_im = np.convolve(up_x_im, rrcos, 'same') plt.figure() plt.grid() plt.title('tx signal real') plt.plot(tx_re[:LEN_PLOT]) #senial recibida rx_re = np.convolve(tx_re, rrcos, 'same') rx_im = np.convolve(tx_im, rrcos, 'same') plt.figure() plt.grid() plt.title('rx signal real') plt.plot(rx_re[:LEN_PLOT]) eyediagram(rx_re, 4, 2, UPSAMPLE) #downsample offset = 2 sample_indexs = range(offset, len(rx_re), UPSAMPLE) down_rx_re = rx_re[sample_indexs] down_rx_im = rx_im[sample_indexs] plt.figure() plt.title('recibed symbols') plt.grid() plt.plot(down_rx_re, down_rx_im, '.') #slicer detection_re = (down_rx_re > 0) * 2 - 1 detection_im = (down_rx_im > 0) * 2 - 1 detection = zip(detection_re, detection_im) plt.show(block=False) raw_input("Aprete cualquier tecla") plt.close()
def send(input_string, m=2, modem=PSKModem, Ts=1e-3, Fs=int(6e4), fc=int(3e3)): # convert string to bitsarray # pylint: disable=too-many-format-args bits_string = text_to_bits(input_string) input_bits = np.array([int(b) for b in bits_string]) # instantiate modem modem = modem(m) # FIX: rounding error in CommPy modem.constellation = _round_complex(np.array(modem.constellation)) # modulate input bits dk = modem.modulate(input_bits) N = len(dk) # weight baseband symbols with Dirac comb function ups = int(Ts * Fs) x = np.zeros(ups * N, dtype='complex') x[::ups] = dk # set pulse shaping filter t0 = 3 * Ts _, rrc = rrcosfilter(N=int(2 * t0 * Fs), alpha=1, Ts=Ts, Fs=Fs) # convolve pulse shaping filter with Dirac comb u = np.convolve(x, rrc) time_sample = np.arange(len(u)) / Fs # define up-converted I and Q components i = u.real q = u.imag iup = i * np.cos(2 * np.pi * time_sample * fc) qup = q * -np.sin(2 * np.pi * time_sample * fc) # define transmitted signal s = iup + qup # TODO: apply channel effects # ..... # define down-converted I and Q components idown = s * np.cos(2 * np.pi * -fc * time_sample) qdown = s * -np.sin(2 * np.pi * fc * time_sample) # set lowpass filter for image rejection BN = 1 / (2 * Ts) cutoff = 5 * BN lowpass_order = 51 lowpass_delay = (lowpass_order // 2) / Fs lowpass = firwin(lowpass_order, cutoff / (Fs / 2)) # lowpass filter down-converted I and Q components idown_lp = lfilter(lowpass, 1, idown) qdown_lp = lfilter(lowpass, 1, qdown) # define sample sample = np.empty((2, len(time_sample))) sample[0, :] = idown_lp sample[1, :] = qdown_lp # define labels label_ids = list( map(lambda s: np.where(modem.constellation == s)[0][0], dk)) labels = np.zeros(ups * N) bins = np.zeros(N + 1) for (i, y) in enumerate(label_ids): labels[i * ups:(i + 1) * ups] = y bins[i + 1] = (i + 1) * Ts delay = t0 + lowpass_delay time_labels = np.arange(len(labels)) / Fs + delay - Ts / 2 bins += delay - Ts / 2 return time_sample, sample, time_labels, labels, bins
def _construct_rrc_filter(self): # filter parameters rrc_len_factor = 6 rrc_alpha_coefficient = 0.4 from commpy.filters import rrcosfilter filter_len_sec = rrc_len_factor * self._symbol_period filter_len_samples = int(filter_len_sec * self._f_sample) _, rrc = rrcosfilter(N=filter_len_samples, alpha=rrc_alpha_coefficient, Ts=self._symbol_period, Fs=self._f_sample) delay = filter_len_sec / 2 return delay, rrc
I_samples = (I_data_raw-127.5)/127.5 Q_samples = (Q_data_raw-127.5)/127.5 complex_data = I_samples + 1j*Q_samples # plt.figure(1) # plt.plot(abs(complex_data)) # plt.grid() data = complex_data[14397:39130] N = 1024 # output size rrcos = rrcosfilter(N*4, 0.8, 1, 24)[1] new_data = np.convolve(rrcos, data) # Waveform with PSF mag = np.abs(new_data) data_x = -1*(20*np.log10((abs(np.fft.fft(mag))))) # plt.plot(np.angle(new_data)) # plt.plot(rrcos) # plt.plot(new_data,'r')
for idx in range(len(bits)): scrambled[idx] = bits[idx] ^ scrambled[idx - 23] ^ scrambled[idx - 18] # Upsample x = np.zeros(num_symbols * samples_per_symbol, dtype=complex) for idx, bitss in enumerate(scrambled.reshape((num_symbols, 2))): x[idx * samples_per_symbol] = (bitss[0]*2-1) + 1j*(bitss[1]*2-1) print(bits) print(scrambled) print(x) # Generate root raised cosine filter num_taps = 50 * samples_per_symbol + int (samples_per_symbol / 2) alpha = 0.35 t, h = filters.rrcosfilter(num_taps, alpha, 1, samples_per_symbol) # Interpolate with RRC tx = np.convolve(x, h) #FFT of tx signal #s = tx * np.hamming(len(tx)) #S = np.fft.fftshift(np.fft.fft(s)) #S_mag = np.abs(S) #f = np.linspace(-0.5,0.5,len(tx)) #plt.figure(0) #plt.plot(f, S_mag,'.-') #plt.show() #Channel rx = tx
def main(): ## Inicializacion de simbolos a transmitir symbolsI = 0x1AA symbolsQ = 0x1FE ## Filtro Tx y Rx #Filtro Root Raised Cosine rc = rrcosfilter(int(Nbauds * os), beta, T, 1. / Ts)[1] #Normalizacion rc = rc[:24] #rc=rc/np.linalg.norm(rc) #lialg.norm ----> Raiz de la suma de los cuadrados de los coeficientes rc = rc / np.sqrt(float(os)) rc_fp = VectorCuantizacion(8, 7, rc, 'trunc') # ### FIR para Canal # #Filtro Root Raised Cosine rch = rcosfilter(int(Nbauds_ch * os), beta, T_ch, 1. / Ts_ch)[1] # # #Normalizacion fir del canal rch = rch[:28] # rch=rch/np.linalg.norm(rch) #rch=rch/np.linalg.norm(rch) #lialg.norm ----> Raiz de la suma de los cuadrados de los coeficientes #rch=rch/np.sqrt(float(os)) #rch_fp= VectorCuantizacion(8,7,rch,'trunc') #canal=np.convolve(rc,rc) ## filtro equivalente, resultado de la convolucion de filtro Tx y FIR canal #canal_fp=VectorCuantizacion(8,7,canal,'trunc') ###--------------------------------------------------- ####Calculos de energia de filtros #Tx energia_tx = 0 for p in range(len(rc)): energia_tx = energia_tx + (rc[p]**2) print "Energia Tx = ", energia_tx # ##FIR canal # energia_rch=0 # for q in range(len(rch)): # energia_rch=energia_rch+(rch[q]**2) # print "Energia rch = ",energia_rch # ##Filtro equivalente de Tx y FIR , canal equivalente # energia_fir_equiv=0 # for w in range(len(canal)): # energia_fir_equiv=energia_fir_equiv+(canal[w]**2) # print "Energia canal equivalente: ", energia_fir_equiv ###--------------------------------------------------- #Grafica de respuesta al impulso del filtro # graf_respImpulso(rc_fp,"Filtro Transmisor Tx") # graf_respImpulso(rch_fp,"Filtro Canal") # graf_respImpulso(canal,"Rc Rch") plt.figure() plt.title("Filtro RRC") plt.plot(rc, 'k-', linewidth=2.0) plt.plot(rc_fp, 'b-', linewidth=2.0) plt.legend() plt.grid(True) plt.xlim(0, len(rc) - 1) plt.xlabel('Muestras') plt.ylabel('Magnitud') # plt.figure() # plt.title("Convolucion TxRx") # plt.plot(canal,'k-',linewidth=2.0) # plt.plot(canal_fp,'b-', linewidth =2.0) # plt.legend() # plt.grid(True) # plt.xlim(0,len(canal)-1) # plt.xlabel('Muestras') # plt.ylabel('Magnitud') # plt.figure() # plt.title("Canal") # plt.plot(canal,'k-',linewidth=2.0) # plt.plot(canal_fp,'b-', linewidth =2.0) # plt.legend() # plt.grid(True) # plt.xlim(0,len(canal)-1) # plt.xlabel('Muestras') # plt.ylabel('Magnitud') #Respuesta en frecuencia [H0, A0, F0] = resp_freq(rc, Ts, Nfreqs) [H1, A1, F1] = resp_freq(rc_fp, Ts, Nfreqs) #Grafica de respuesta en frecuencia del filtro #graf_respFrecuencia(H0,A0,F0,"Filtro Transmisor") plt.figure() plt.title( 'Respuesta en frecuencia convolucion filtro transmisor y receptor') plt.semilogx(F0, 20 * np.log10(H0), 'r', linewidth=2.0, label=r'$\beta=0.5$') plt.semilogx(F1, 20 * np.log10(H1), 'b', linewidth=2.0, label=r'$\beta=0.5$') #plt.axvline(x=(1./Ts)/2.,color='k',linewidth=2.0) #plt.axvline(x=(1./T)/2.,color='k',linewidth=2.0) plt.axhline(y=20 * np.log10(0.5), color='k', linewidth=2.0) plt.legend(loc=3) plt.grid(True) #plt.xlim(F0[1],F0[len(F0)-1]) plt.xlabel('Frequencia [Hz]') plt.ylabel('Magnitud [dB]') #Grafica de respuesta al impulso del filtro # graf_respImpulso(rcoseno,"convolucion filtro transmisor y receptor") #Respuesta en frecuencia # [H1,A1,F1]=resp_freq(rcoseno, Ts, Nfreqs) #Grafica de respuesta en frecuencia del filtro # graf_respFrecuencia(H1,A1,F1,"convolucion filtro transmisor y receptor") #Shift register del transmisor y receptor shift_tx_I = np.zeros(24) shift_tx_Q = np.zeros(24) shift_rx_I = np.zeros(24) shift_rx_Q = np.zeros(24) #Bit transmitidos para comparar en la BER trans_berI = np.zeros(1024) trans_berQ = np.zeros(1024) #Bit recibios para comprar en la BER recib_berI = np.zeros(511) recib_berQ = np.zeros(511) #Salida del filtro transmisor out_tx_I = 0 out_tx_Q = 0 out_tx_I_fp = DeFixedInt(7, 6, 'S', 'trunc') #Punto Fijo out_tx_Q_fp = DeFixedInt(7, 6, 'S', 'trunc') #Salida de del canal mas el ruido # out_ch_I=0 # out_ch_Q=0 # out_ch_I= DeFixedInt(8,7) #Punto Fijo # out_ch_Q= DeFixedInt(8,7) #Salida del filtro receptor rx_I = 0 rx_Q = 0 rx_I_fp = DeFixedInt(7, 6, 'S', 'trunc') #Punto Fijo rx_Q_fp = DeFixedInt(7, 6, 'S', 'trunc') #Valor obtenido del Slicer (detector) ak_I = 0 ak_Q = 0 #Salida del FIR del Equalizador y_I = 0 y_Q = 0 y_I_fp = DeFixedInt(9, 7, 'S', 'trunc') y_Q_fp = DeFixedInt(9, 7, 'S', 'trunc') #Error realimentacion Equalizador error_adap_I = 0 error_adap_Q = 0 error_adap_I_fp = DeFixedInt(7, 6, 'S', 'trunc') error_adap_Q_fp = DeFixedInt(7, 6, 'S', 'trunc') offset = 1 phase_I = np.zeros(4) phase_Q = np.zeros(4) #Variables utilizadas en la sincronizacion error_actual = 0 error_minimo = 99999 pos_trans = 0 pos_aux = 0 cont_ber = 0 #Variables utilizadas post sincronizacion error_final = 0 cant_muestras = 0 #Habilitacion Prbs, Ber value = 0 delta = 0.0115 # delta=0.005 #Cantidad de coeficientes FIR del ecualizador Ntap = 31 #Memoria del filtro FIR Ecualizador mem_fir_adap_I = np.zeros(Ntap) mem_fir_adap_Q = np.zeros(Ntap) #Coeficientes del filtro FIR del ecualizador adaptativo coef_fir_adap_I = np.zeros(Ntap) coef_fir_adap_Q = np.zeros(Ntap) #Pos 15 = 1 inicializacion coef_fir_adap_I[(Ntap - 1) / 2] = 1 coef_fir_adap_Q[(Ntap - 1) / 2] = 1 coef_fir_adap_I_fp = DeFixedInt(10, 8, 'S', 'sature') coef_fir_adap_Q_fp = DeFixedInt(10, 8, 'S', 'sature') diezmado = 2 end_sync = 0 #Bandera indica fin etapa de sincronizacion (1) graficar = 0 #Cuando esta en 1 almacena valores para luego graficar # #Memoria del canal mem_canal_I = np.zeros(len(rch)) mem_canal_Q = np.zeros(len(rch)) #Usados para graficar senial_transmitir_I = [] senial_transmitir_Q = [] senial_recibida_I = [] senial_recibida_Q = [] senial_recibida_diezmada_I = [] senial_recibida_diezmada_Q = [] coeficientes = [] error_tiempo = [] input_equ = [] var_tx = [] var_rx = [] var_ch = [] #CURVA BER SIMULADA snr = [100.] #,20.]#,100.,16.,14.,12.,10.,8.,6.,4.,2.] ber = [] snr_iteraciones = [ 100000 ] #+ 2097153,100000+100000]#,100000,100000,100000,100000,100000,100000,100000] for t in range(len(snr_iteraciones)): error_final = 0 # noise_vector_I=noise(snr[t],snr_iteraciones[t],energia_tx/4) #genero senial de ruido # noise_vector_Q=noise(snr[t],snr_iteraciones[t],energia_tx/4) print "snr_iter: ", snr_iteraciones[t] print "t: ", t for i in range(0, snr_iteraciones[t]): value = i % os if (i == 0): sym_t_I = 0 sym_t_Q = 0 else: sym_t_I = out_tx_I_fp.fValue sym_t_Q = out_tx_Q_fp.fValue shift_tx_I = ShiftReg(shift_tx_I) shift_tx_Q = ShiftReg(shift_tx_Q) if (value == 0): #es multiplo de 4? symbolsI = PRBS9(symbolsI) #Generacion de simbolos symbolsQ = PRBS9(symbolsQ) if ((symbolsI >> 8) & 0x001 == 0): shift_tx_I[0] = 1 else: shift_tx_I[0] = -1 if ((symbolsQ >> 8) & 0x001 == 0): shift_tx_Q[0] = 1 else: shift_tx_Q[0] = -1 trans_berI = ShiftReg(trans_berI) trans_berQ = ShiftReg(trans_berQ) trans_berI[0] = shift_tx_I[ 0] #Agrego nuevo valor transmitido a arreglo bits transmitidos trans_berQ[0] = shift_tx_Q[0] else: #Oversampling shift_tx_I[0] = 0 shift_tx_Q[0] = 0 ## Convolucion transmisor, senial transmitida out_tx_I = np.sum(rc * shift_tx_I) out_tx_Q = np.sum(rc * shift_tx_Q) # if(i%4): # var_tx.append(out_tx_I) out_tx_I_fp.value = out_tx_I #+noise_vector_I[i] out_tx_Q_fp.value = out_tx_Q #+noise_vector_Q[i] # ### # Canal # ### # mem_canal_I = ShiftReg(mem_canal_I) #corrimiento de memoria del canal # mem_canal_Q = ShiftReg(mem_canal_Q) # mem_canal_I[0]=out_tx_I #agregamos nuevo valor de salida de Tx a la memoria # mem_canal_Q[0]=out_tx_Q # out_ch_I=np.sum(mem_canal_I*(rch)) #salida Tx pasa por canal # out_ch_Q=np.sum(mem_canal_Q*(rch)) # if(i%4): # var_ch.append(out_ch_I) shift_rx_I = ShiftReg(shift_rx_I) shift_rx_Q = ShiftReg(shift_rx_Q) shift_rx_I[0] = sym_t_I shift_rx_Q[0] = sym_t_Q ##Convolucion receptor, senial recibida rx_I = np.sum(rc * shift_rx_I) rx_Q = np.sum(rc * shift_rx_Q) rx_I_fp.value = rx_I rx_Q_fp.value = rx_Q # if(i%4 and t==0): # input_equ.append(abs(rx_I)) # rx_I = rx_I *vect_pond[t] # rx_Q = rx_Q *vect_pond[t] # rx_I=rx_I*pond # rx_Q=rx_Q*pond # if(max_rx[t] < abs(rx_I)): # max_rx[t] = abs(rx_I) # print "Salida Rx: ",rx_I #### ###FIR ECUALIZADOR ##### if ((i % 2 != 0) and (i != 0)): #nos quedamos con muestras 1 y 3 mem_fir_adap_I = ShiftReg(mem_fir_adap_I) mem_fir_adap_Q = ShiftReg(mem_fir_adap_Q) mem_fir_adap_I[0] = rx_I_fp.fValue mem_fir_adap_Q[0] = rx_Q_fp.fValue if ((value == 0) and i != 0): #for r in range(0,Ntap-1): y_I = np.sum(coef_fir_adap_I * mem_fir_adap_I) #FIR y_Q = np.sum(coef_fir_adap_Q * mem_fir_adap_Q) #FIR y_I_fp.value = y_I y_Q_fp.value = y_Q #Slicer ak_I = (2 * (y_I_fp.fValue >= 0) - 1) ak_Q = (2 * (y_Q_fp.fValue >= 0) - 1) #------------------------------------------Algoritmo de adaptacion error_adap_I = ak_I - y_I_fp.fValue error_adap_Q = ak_Q - y_Q_fp.fValue error_adap_I_fp.value = error_adap_I error_adap_Q_fp.value = error_adap_Q if (i % 4 == 0): coeficientes.append(coef_fir_adap_I.copy()) for b in range(0, Ntap): coef_fir_adap_I[b] = coef_fir_adap_I[ b] + delta * error_adap_I_fp.fValue * mem_fir_adap_I[b] coef_fir_adap_Q[b] = coef_fir_adap_Q[ b] + delta * error_adap_Q_fp.fValue * mem_fir_adap_Q[b] # print("COEF I SIN FIX") # print ("sin fix",coef_fir_adap_I) # print("NOSE",coef_fir_adap_I_fp) # for b in range(0,Ntap): # coef_fir_adap_I_fp.value=coef_fir_adap_I[b] # coef_fir_adap_I[b]=coef_fir_adap_I_fp.fValue # print("FIX",coef_fir_adap_I) for b in range(0, Ntap): coef_fir_adap_I_fp.value = coef_fir_adap_I[b] coef_fir_adap_I[b] = coef_fir_adap_I_fp.fValue coef_fir_adap_Q_fp.value = coef_fir_adap_Q[b] coef_fir_adap_Q[b] = coef_fir_adap_Q_fp.fValue # # raw_input('Press Enter to Continue') # print("COEF I CON FIX") # for b in range(0,Ntap): # print (coef_fir_adap_I[b]) ##Ber # if(i>1000): # if((value==0) and i!=0): # recib_berI = ShiftReg(recib_berI) # recib_berQ = ShiftReg(recib_berQ) # recib_berI[0]=ak_I #Bits recibidos # recib_berQ[0]=ak_Q #Bits recibidos # if(end_sync==0): ##Etapa de sincronizacion # if(cont_ber<511): # cont_ber=cont_ber+1 # else: #cont_ber==511 # cont_ber=0 # if(error_actual<error_minimo): # print "Error minimo actual: ",error_actual # print "Pos error minimo actual: ",pos_trans # error_minimo=error_actual # error_actual=0 # pos_aux=pos_trans # else: # error_actual=0 # if(pos_trans!=1023): # pos_trans=pos_trans+1 # else: #finalizo etapa de sincronizacion # pos_trans=pos_aux # end_sync=1 # # print "end_sync",end_sync # #graficar=1 # if(recib_berI[0]!=trans_berI[pos_trans]): # error_actual=error_actual+1 # if(recib_berQ[0]!=trans_berQ[pos_trans]): # error_actual=error_actual+1 # else: #end_sync==1 pos sincronizacion # cant_muestras=cant_muestras+1 # # print "end_sync" # # if(end_sync==1): # # print "Bit recibido en BER: ", ak_I # # raw_input('Press Enter to Continue') # # plt.close() # if(recib_berI[0]!=trans_berI[pos_trans]): # error_final=error_final+1 # if(recib_berQ[0]!=trans_berQ[pos_trans]): # error_final=error_final+1 # if(i==(snr_iteraciones[t]-4)): # print "snr",snr[t] # print "error_final", error_final # ber.append(float(error_final)/(((snr_iteraciones[t]/os)*2))) # print ber # print "VAR_TX", np.var(var_tx) # print "VAR_RX", np.var(var_rx) # print "VAR_CH", np.var(var_ch) # print "SNR = ", snr[t], " Maximo = ", max_rx[t] # print "SNR = %d - Maximo = %d" %(snr[t],max_rx[t]) # suma=0 # for w in range (len(input_equ)): # suma=suma + input_equ[w] # plt.figure() # plt.title("Entrada Ecualizador") # plt.plot(input_equ,".") # print "Cantidad de muestras para la media ", len(input_equ) # print "MEDIA:", suma/len(input_equ) # print "Vector de Maximos", max_rx #print "BER: ", ber #print error_minimo #print pos_aux ##Grafico de simbolos transmitidos #graf_simbTransmitidos(shift_tx_I,shift_tx_Q) ### Convolucion transmisor, senial transmitida #graf_Convolucion(senial_transmitir_I, "transmitida") ##Grafico diagrama ojo transmisor #eyediagram(senial_transmitir_I[100:len(senial_transmitir_I)-100],os,0,Nbauds) #eyediagram(senial_transmitir_Q[100:len(senial_transmitir_Q)-100],os,0,Nbauds) ##Convolucion receptor, senial recibida #graf_Convolucion(var_rx,"recibida") ##Grafica curvas Ber-teorica y simulada #graf_BER(snr,ber) ##Grafico diagrama ojo receptor #eyediagram(senial_recibida_I[100:len(senial_recibida_I)-100],os,0,Nbauds) #eyediagram(senial_recibida_Q[100:len(senial_recibida_Q)-100],os,0,Nbauds) ##Constelaciones # plt.figure() # plt.title("Constelaciones") # plt.plot(senial_recibida_diezmada_I[(offset):len(senial_recibida_diezmada_I)-((offset)):int(os)], # senial_recibida_diezmada_Q[(offset):len(senial_recibida_diezmada_Q)-((offset)):int(os)], # 'r.',linewidth=2.0) # plt.axis('equal') # plt.grid(True) # plt.xlabel('Real') # plt.ylabel('Imag') # plt.figure() # plt.title("Error en la adaptacion") # plt.plot(error_tiempo) plt.figure() plt.title("Coeficientes en el tiempo") plt.plot(coeficientes) # print len(coeficientes) plt.figure() plt.title("Ultimos coeficientes del filtro FIR") plt.stem(coeficientes[len(coeficientes) - 1]) #equa=np.convolve(rcoseno,np.transpose(coeficientes[len(coeficientes)-1])) # ## Grafica de respuesta al impulso del filtro # graf_respImpulso(equa,"a la salida del equalizador") # ## Respuesta en frecuencia # [H2,A2,F2]=resp_freq(equa, Ts, Nfreqs) # ## Grafica de respuesta en frecuencia del filtro # graf_respFrecuencia(H2,A2,F2,"a la salida del ecualizador") plt.show(block=False) raw_input('Press Enter to Continue') plt.close()
mag = np.abs(m_filter) d=int(len(m_filter)) magnitude = np.abs(m_filter) plt.figure(1) plt.plot((m_filter)) plt.grid() data_x = (20*np.log10((abs(np.fft.fft(mag))))) #Scipy Website Commpy Library root raised Cosines rrcos = rrcosfilter(1*2, 0.5, 1, 2400000)[1] f_sample_factor=11 sinc_func=np.sin(np.arange(0,f_sample_factor,1)*np.pi/f_sample_factor) rollof=10 rrcos_2=3*np.sinc(np.arange(-rollof,rollof,0.5)*np.pi/rollof) filterout_t=np.correlate((m_filter),sinc_func) mag = np.abs(filterout_t) angle = np.angle(filterout_t) unwrap = np.unwrap(angle) fft_1 = 20*np.log10(np.abs(np.fft.fft(np.abs(filterout_t ),sample_rate)))
import numpy as np import matplotlib.pyplot as plt import commpy.filters as matlab filename_out = 'yeet.txt' file_out = open(filename_out,'w+') L = 5 beta = .12 #length rolloff ts fs [filt,bad] = matlab.rrcosfilter(L,beta,5,1) print(filt) plt.stem(filt) plt.show()
# PYTHONPATH=./tutorial-env/lib/python3.5/site-packages/commpy python rrc-coeffs.py import numpy as np import matplotlib.pyplot as plt from commpy import filters Fs = 1000 # Sampling rate of 1kHz Ts = 0.01 # Symbol length of 10ms (i.e. 10 samples per symbol) # the RRC filter should span 3 baseband samples to the left and to the right. # Hence, it introduces a delay of 3Ts seconds. t0 = 3*Ts _, rrc = filters.rrcosfilter(N=int(2*t0*Fs), alpha=1,Ts=Ts, Fs=Fs) t_rrc = np.arange(len(rrc)) / Fs plt.plot(t_rrc/Ts, rrc) plt.show() # Now give us coefficients in A(2,13) format for coeff in rrc: fp_coeff = int((2**13)*coeff); print(format(fp_coeff & 0xffff, '04x'))
l = 0 for line in fileobject: reading = line[0:line.find(",")] raw_samples.append(complex(reading)) l = +1 fileobject.close() # print(raw_samples) #################Read From Textfile################## # set carrier frequency fsy = 100000 samplefreq = 2.4e6 fsymrate = 1.3e9 # + fsy time, h_t = rrcosfilter(30000, 0.5, 8 / fsy, fsy) # h_t = h_t/np.max(h_t) # raw_samples = raw_samples/np.max(raw_samples) jaaaa = signal.fftconvolve((raw_samples), h_t, mode='full') # rawsquare = np.square(raw_samples) # mag = np.sqrt(jaaaa.real()**2 + jaaaa.imag()**2) jaaaa = jaaaa[15000:45000] # /np.max(jaaaa) t = np.arange(0, 30000 / samplefreq, 1 / samplefreq) clock = 0.5 * np.cos(fsy * 2 * np.pi * t + 22 * np.pi / 10) + .5 # vir DBPSK print(t[0:10]) print(time[0:10]) plt.figure() plt.plot(np.real(jaaaa), label='filter')
def main(): ## Inicializacion de simbolos a transmitir symbolsI = 0x1AA symbolsQ = 0x1FE ## Filtro Tx y Rx #Filtro Root Raised Cosine rc = rrcosfilter(int(Nbauds * os), beta, T, 1. / Ts)[1] #Normalizacion #(t,rc)=rrcosine(beta, T, os, Nbauds) rc = rc[:24] #rc=rc/np.linalg.norm(rc) #lialg.norm ----> Raiz de la suma de los cuadrados de los coeficientes rc = rc / np.sqrt(float(os)) # ### FIR para Canal # #Filtro Root Raised Cosine #rch=rcosfilter(int(Nbauds_ch*os),beta,T_ch,1./Ts_ch)[1] #(t,rch)=rcosine(beta, T_ch, os_ch, Nbauds_ch,0) # # #Normalizacion fir del canal #rch=rch[:28] rch = np.zeros(28) rch[13] = 1 #rch=rch/np.linalg.norm(rch) #lialg.norm ----> Raiz de la suma de los cuadrados de los coeficientes #rch=rch/np.sqrt(float(os)) canal = np.convolve( rc, rch ) ## filtro equivalente, resultado de la convolucion de filtro Tx y FIR canal ###--------------------------------------------------- ####Calculos de energia de filtros #Tx energia_tx = 0 for p in range(len(rc)): energia_tx = energia_tx + (rc[p]**2) print "Energia Tx = ", energia_tx ##FIR canal energia_rch = 0 for q in range(len(rch)): energia_rch = energia_rch + (rch[q]**2) print "Energia rch = ", energia_rch ##Filtro equivalente de Tx y FIR , canal equivalente energia_fir_equiv = 0 for w in range(len(canal)): energia_fir_equiv = energia_fir_equiv + (canal[w]**2) print "Energia canal equivalente: ", energia_fir_equiv ###--------------------------------------------------- #Grafica de respuesta al impulso del filtro graf_respImpulso(rc, "Filtro Transmisor Tx") graf_respImpulso(rch, "Filtro Canal") graf_respImpulso(canal, "Rc Rch") # plt.show(block=False) # raw_input('Press Enter to Continue') # plt.close() # exit(0) # plt.show(block=False) # raw_input('Press Enter to Continue') # plt.close() # exit() #Respuesta en frecuencia # [H0,A0,F0]=resp_freq(rc, Ts, Nfreqs) #Grafica de respuesta en frecuencia del filtro # graf_respFrecuencia(H0,A0,F0,"Filtro Transmisor") # rcoseno=np.convolve(rc,rc) #Grafica de respuesta al impulso del filtro # graf_respImpulso(rcoseno,"convolucion filtro transmisor y receptor") #Respuesta en frecuencia # [H1,A1,F1]=resp_freq(rcoseno, Ts, Nfreqs) #Grafica de respuesta en frecuencia del filtro # graf_respFrecuencia(H1,A1,F1,"convolucion filtro transmisor y receptor") #Shift register del transmisor y receptor shift_tx_I = np.zeros(24) shift_tx_Q = np.zeros(24) shift_rx_I = np.zeros(24) shift_rx_Q = np.zeros(24) #Bit transmitidos para comparar en la BER trans_berI = np.zeros(1024) trans_berQ = np.zeros(1024) #Bit recibios para comprar en la BER recib_berI = np.zeros(511) recib_berQ = np.zeros(511) #Salida del filtro transmisor out_tx_I = 0 out_tx_Q = 0 #Salida de del canal mas el ruido # out_ch_I=0 # out_ch_Q=0 #Valor obtenido del Slicer (detector) ak_I = 0 ak_Q = 0 y_I = 0 y_Q = 0 offset = 1 phase_I = np.zeros(4) phase_Q = np.zeros(4) #Variables utilizadas en la sincronizacion error_actual = 0 error_minimo = 99999 pos_trans = 0 pos_aux = 0 cont_ber = 0 #Variables utilizadas post sincronizacion error_final = 0 cant_muestras = 0 #Habilitacion Prbs, Ber value = 0 delta = 0.0115 # delta=0.005 #Cantidad de coeficientes FIR del ecualizador Ntap = 31 #Memoria del filtro FIR Ecualizador mem_fir_adap_I = np.zeros(Ntap) mem_fir_adap_Q = np.zeros(Ntap) #Coeficientes del filtro FIR del ecualizador adaptativo coef_fir_adap_I = np.zeros(Ntap) coef_fir_adap_Q = np.zeros(Ntap) #Pos 15 = 1 inicializacion coef_fir_adap_I[(Ntap - 1) / 2] = 1 coef_fir_adap_Q[(Ntap - 1) / 2] = 1 diezmado = 2 end_sync = 0 #Bandera indica fin etapa de sincronizacion (1) graficar = 0 #Cuando esta en 1 almacena valores para luego graficar # #Memoria del canal mem_canal_I = np.zeros(len(rch)) mem_canal_Q = np.zeros(len(rch)) #Maximos y minimos max_rx = np.zeros(9) #Ponderacion #vect_pond=[0.93,0.74,0.70,0.64,0.56,0.52,0.48,0.44,0.4] impulso con /2 #vect_pond=[0.93,0.65,0.62,0.53,0.47,0.42,0.38,0.33,0.28] impulso #vect_pond=[0.49,0.42,0.40,0.37,0.36,0.33,0.30,0.27,0.25] dividio 2 vect_pond = [0.5, 0.36, 0.33, 0.31, 0.28, 0.25, 0.22, 0.19, 0.17] #Usados para graficar senial_transmitir_I = [] senial_transmitir_Q = [] senial_recibida_I = [] senial_recibida_Q = [] senial_recibida_diezmada_I = [] senial_recibida_diezmada_Q = [] coeficientes = [] error_tiempo = [] input_equ = [] input_equ_m = [] input_equ_2 = [] output_tx = [] var_tx = [] var_rx = [] var_ch = [] #CURVA BER SIMULADA snr = [100., 16., 14., 12., 10., 8., 6., 4., 2.] ber = [] #2097153 snr_iteraciones = [ 100000 + 2097153, 100000 + 1000000, 100000 + 1000000, 100000 + 1000000, 100000 + 1000000, 100000 + 1000000, 100000 + 1000000, 100000 + 1000000, 100000 + 1000000 ] # snr_iteraciones=[100000,100000,100000,100000,100000,100000,100000,100000,100000] for t in range(len(snr_iteraciones)): error_final = 0 noise_vector_I = noise(snr[t], snr_iteraciones[t], energia_fir_equiv / 1.2) #genero senial de ruido noise_vector_Q = noise(snr[t], snr_iteraciones[t], energia_fir_equiv / 1.2) print "snr_iter: ", snr_iteraciones[t] print "snr", snr[t] for i in range(0, snr_iteraciones[t]): value = i % os if (i == 0): sym_t_I = 0 sym_t_Q = 0 else: sym_t_I = out_ch_I + noise_vector_I[i] sym_t_Q = out_ch_Q + noise_vector_Q[i] shift_tx_I = ShiftReg(shift_tx_I) shift_tx_Q = ShiftReg(shift_tx_Q) if (value == 0): #es multiplo de 4? symbolsI = PRBS9(symbolsI) #Generacion de simbolos symbolsQ = PRBS9(symbolsQ) if ((symbolsI >> 8) & 0x001 == 0): shift_tx_I[0] = 1 else: shift_tx_I[0] = -1 if ((symbolsQ >> 8) & 0x001 == 0): shift_tx_Q[0] = 1 else: shift_tx_Q[0] = -1 trans_berI = ShiftReg(trans_berI) trans_berQ = ShiftReg(trans_berQ) trans_berI[0] = shift_tx_I[ 0] #Agrego nuevo valor transmitido a arreglo bits transmitidos trans_berQ[0] = shift_tx_Q[0] else: #Oversampling shift_tx_I[0] = 0 shift_tx_Q[0] = 0 ## Convolucion transmisor, senial transmitida out_tx_I = np.sum(rc * shift_tx_I) out_tx_Q = np.sum(rc * shift_tx_Q) # if(i%4): # var_tx.append(out_tx_I) # ### # Canal # ### mem_canal_I = ShiftReg( mem_canal_I) #corrimiento de memoria del canal mem_canal_Q = ShiftReg(mem_canal_Q) mem_canal_I[ 0] = out_tx_I #agregamos nuevo valor de salida de Tx a la memoria mem_canal_Q[0] = out_tx_Q out_ch_I = np.sum(mem_canal_I * (rch)) #salida Tx pasa por canal out_ch_Q = np.sum(mem_canal_Q * (rch)) # if(i%4): # var_ch.append(out_ch_I) shift_rx_I = ShiftReg(shift_rx_I) shift_rx_Q = ShiftReg(shift_rx_Q) shift_rx_I[0] = sym_t_I shift_rx_Q[0] = sym_t_Q ##Convolucion receptor, senial recibida rx_I = np.sum(rc * shift_rx_I) rx_Q = np.sum(rc * shift_rx_Q) # if(max_rx[t]<rx_I): # max_rx[t]=rx_I rx_I = rx_I * vect_pond[t] rx_Q = rx_Q * vect_pond[t] input_equ.append(rx_I) # if(rx_I>1.0): # input_equ_m.append(abs(rx_I)) #### ###FIR ECUALIZADOR ##### if ((i % 2 != 0) and (i != 0)): #nos quedamos con muestras 1 y 3 mem_fir_adap_I = ShiftReg(mem_fir_adap_I) mem_fir_adap_Q = ShiftReg(mem_fir_adap_Q) mem_fir_adap_I[0] = rx_I mem_fir_adap_Q[0] = rx_Q if ((value == 0) and i != 0): #for r in range(0,Ntap-1): y_I = np.sum(coef_fir_adap_I * mem_fir_adap_I) #FIR y_Q = np.sum(coef_fir_adap_Q * mem_fir_adap_Q) #FIR #Slicer ak_I = (2 * (y_I >= 0) - 1) ak_Q = (2 * (y_Q >= 0) - 1) #------------------------------------------Algoritmo de adaptacion error_adap_I = ak_I - y_I error_adap_Q = ak_Q - y_Q if (i % 8 == 0): coeficientes.append(coef_fir_adap_I.copy()) for b in range(0, Ntap): coef_fir_adap_I[b] = coef_fir_adap_I[ b] + delta * error_adap_I * mem_fir_adap_I[b] coef_fir_adap_Q[b] = coef_fir_adap_Q[ b] + delta * error_adap_Q * mem_fir_adap_Q[b] ##Ber if (i > 100000): if ((value == 0) and i != 0): recib_berI = ShiftReg(recib_berI) recib_berQ = ShiftReg(recib_berQ) recib_berI[0] = ak_I #Bits recibidos recib_berQ[0] = ak_Q #Bits recibidos if (end_sync == 0): ##Etapa de sincronizacion if (cont_ber < 511): cont_ber = cont_ber + 1 else: #cont_ber==511 cont_ber = 0 if (error_actual < error_minimo): print "Error minimo actual: ", error_actual print "Pos error minimo actual: ", pos_trans error_minimo = error_actual error_actual = 0 pos_aux = pos_trans else: error_actual = 0 if (pos_trans != 1023): pos_trans = pos_trans + 1 else: #finalizo etapa de sincronizacion pos_trans = pos_aux end_sync = 1 if (recib_berI[0] != trans_berI[pos_trans]): error_actual = error_actual + 1 if (recib_berQ[0] != trans_berQ[pos_trans]): error_actual = error_actual + 1 else: #end_sync==1 pos sincronizacion cant_muestras = cant_muestras + 1 if (recib_berI[0] != trans_berI[pos_trans]): error_final = error_final + 1 if (recib_berQ[0] != trans_berQ[pos_trans]): error_final = error_final + 1 if (i == (snr_iteraciones[t] - 4)): print "snr", snr[t] print "error_final", error_final ber.append( float(error_final) / ((((snr_iteraciones[t] - 100000) / os) * 2))) print ber # print "Media Tx",np.mean(output_tx) # print "Media", np.mean(input_equ) # print "Media", np.mean(input_equ_m) # print "VAR_TX", np.var(var_tx) # print "VAR_RX", np.var(var_rx) # print "VAR_CH", np.var(var_ch) # for k in range (0,len(max_rx)): # print "SNR = ", snr[k], " Maximo = ", max_rx[k] # print "SNR = %d - Maximo = %d" %(snr[t],max_rx[t]) # suma=0 # for w in range (len(input_equ)): # suma=suma + input_equ[w] plt.figure() plt.title("Entrada Ecualizador") plt.plot(input_equ) # print "Cantidad de muestras para la media ", len(input_equ) # print "MEDIA:", suma/len(input_equ) # print "Vector de Maximos", max_rx print "BER: ", ber #print error_minimo #print pos_aux ##Grafico de simbolos transmitidos #graf_simbTransmitidos(shift_tx_I,shift_tx_Q) ### Convolucion transmisor, senial transmitida #graf_Convolucion(senial_transmitir_I, "transmitida") ##Grafico diagrama ojo transmisor #eyediagram(senial_transmitir_I[100:len(senial_transmitir_I)-100],os,0,Nbauds) #eyediagram(senial_transmitir_Q[100:len(senial_transmitir_Q)-100],os,0,Nbauds) ##Convolucion receptor, senial recibida #graf_Convolucion(var_rx,"recibida") ##Grafica curvas Ber-teorica y simulada #graf_BER(snr,ber) ##Grafico diagrama ojo receptor # eyediagram(senial_recibida_I[100:len(senial_recibida_I)-100],os,0,Nbauds) # eyediagram(senial_recibida_Q[100:len(senial_recibida_Q)-100],os,0,Nbauds) # plt.figure() # plt.plot(senial_recibida_I) ##Constelaciones # plt.figure() # plt.title("Constelaciones") # plt.plot(senial_recibida_diezmada_I[(offset):len(senial_recibida_diezmada_I)-((offset)):int(os)], # senial_recibida_diezmada_Q[(offset):len(senial_recibida_diezmada_Q)-((offset)):int(os)], # 'r.',linewidth=2.0) # plt.axis('equal') # plt.grid(True) # plt.xlabel('Real') # plt.ylabel('Imag') # plt.figure() # plt.title("Error en la adaptacion") # plt.plot(error_tiempo) plt.figure() plt.title("Coeficientes en el tiempo") plt.plot(coeficientes) # print len(coeficientes) plt.figure() plt.title("Ultimos coeficientes del filtro FIR") plt.stem(coeficientes[len(coeficientes) - 1]) #equa=np.convolve(rcoseno,np.transpose(coeficientes[len(coeficientes)-1])) # ## Grafica de respuesta al impulso del filtro # graf_respImpulso(equa,"a la salida del equalizador") # ## Respuesta en frecuencia # [H2,A2,F2]=resp_freq(equa, Ts, Nfreqs) # ## Grafica de respuesta en frecuencia del filtro # graf_respFrecuencia(H2,A2,F2,"a la salida del ecualizador") plt.show(block=False) raw_input('Press Enter to Continue') plt.close()
def evmMeter(signalIn, symbolsIn, fs, freqMix, debugMode=False): # Generating reference signal ts = 1e-6 osr = int(fs * ts) numberSamples = int(8 * osr) time, pulseShape = com.rrcosfilter(numberSamples, 0.5, ts, fs) symbolsUp = np.zeros( symbolsIn.size * osr) + 1j * np.zeros(symbolsIn.size * osr) symbolsUp[0::osr] = symbolsIn phaseInc = 2 * np.pi * freqMix / fs * np.ones(symbolsUp.size + pulseShape.size - 1) signalRef = np.convolve(symbolsUp, pulseShape) * np.exp( 1j * phaseInc.cumsum()) #timeMix = np.arange(0, symbolsUp.size + pulseShape.size - 1) * (1 / fs) #signalRef = np.convolve(symbolsUp, pulseShape) * np.exp(2j * np.pi * freqMix * timeMix) signalRefLevel = np.sqrt(np.abs(np.mean(signalRef * signalRef.conj()))) if (debugMode): signalPlotting(signalRef, fs, 'Signal Ref') signalPlotting(signalIn, fs, 'Signal Ref') if (debugMode): fig1, (ax1, ax12) = plt.subplots(figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k', ncols=1, nrows=2, sharex=False) ax1.plot(signalRef.real, 'b', label='real') ax1.plot(signalRef.imag, 'r', label='imag') ax1.set_title( f'Signal Ref Level = {signalRefLevel} with length {signalRef.size}' ) ax1.legend() ax12.plot(signalIn.real, 'b', label='real') ax12.plot(signalIn.imag, 'r', label='imag') ax12.set_title(f'Signal In with length {signalIn.size}') ax12.legend() # Calculate EVM # Check lenghts are ok if signalIn.size < signalRef.size: raise SyntaxError( 'ERROR: DSPFunctions::evmMeter - Signal is shorter than reference.' ) crossCorrelSignal = np.correlate(signalIn, signalRef, 'full') index = np.arange(-np.max([signalIn.size, signalRef.size]) + 1, np.max([signalIn.size, signalRef.size]), 1) indexAligned = index[-crossCorrelSignal.size:] indexAligned = indexAligned[int(indexAligned.size / 2):] crossCorrelSignal = crossCorrelSignal[int(crossCorrelSignal.size / 2):] lag = indexAligned[np.abs(crossCorrelSignal).argmax()] if (lag < 0): raise SyntaxError( 'ERROR: DSPFunction::evmMeter - index of correlation is negative.') if (debugMode): fig2, ax2 = plt.subplots(figsize=(10, 8)) ax2.plot(signalIn.real, 'b', label='Signal In Real') ax2.plot(signalRef.real, 'g', label='Signal Ref Real') ax2.plot(indexAligned, np.abs(crossCorrelSignal) / np.abs(crossCorrelSignal).max(), 'r', label='CrossCorrelation') ax2.set_title(f'Cross-correlation lag = {lag}') ax2.legend() # chopping signals signalInChop = signalIn[lag:] if (debugMode): print('Lag = ', lag, 'signalInChop = ', signalInChop.size, 'signalIn = ', signalIn.size) print(signalIn[:10].real * 1e3) print(signalInChop[:10].real * 1e3) signalLen = np.min([signalInChop.size, signalRef.size]) if (debugMode): print('signalInChop = ', signalInChop.size) print('signalLen = ', signalLen) signalInChop = signalInChop[:signalLen] signalRefChop = signalRef[:signalLen] if (debugMode): print('signalLen = ', signalLen) print(signalIn[:10].real * 1e3) print(signalInChop[:10].real * 1e3) if (debugMode): print('signalInChop = ', signalInChop.size, ' signalRefChop = ', signalRefChop.size) if (debugMode): fig3, (ax3, ax4) = plt.subplots(figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k', ncols=1, nrows=2, sharex=False) signalInChopLevel = np.sqrt( np.abs(np.mean(signalInChop * signalInChop.conj()))) gain = signalRefLevel / signalInChopLevel ax3.plot(signalRefChop.real, 'b', label='Ref real') ax3.plot(gain * signalInChop.real, 'r--', label='Signal In real') ax3.legend() ax3.set_title(f'Signal ref Chopped - length = {signalRefChop.size}') ax4.plot(signalRefChop.imag, 'b', label='Ref imag') ax4.plot(gain * signalInChop.imag, 'r--', label='Signal In imag') ax4.legend() ax4.set_title(f'Signal In Chopped - length = {signalInChop.size}') # Input Signal level and rotation signalInLevel = np.sqrt(np.abs(np.mean(signalInChop * signalInChop.conj()))) signalInRot = (signalRefLevel / signalInLevel) * np.exp( -1j * np.angle(crossCorrelSignal.max())) * signalInChop if (debugMode): fig5, ax5 = plt.subplots(figsize=(10, 8)) ax5.plot(signalInRot.real, 'b', label='Rot Real') ax5.plot(signalInRot.imag, 'r', label='Rot Imag') ax5.plot(gain * signalInChop.real, 'b--', label='Org Real') ax5.plot(gain * signalInChop.imag, 'r--', label='Org Imag') ax5.set_title( f'Rot Signal angle {np.angle(crossCorrelSignal.max())}, signalRefLevel = {signalRefLevel}, signalInLevel = {signalInLevel}' ) ax5.legend() # Error Vector errorVector = signalInRot - signalRefChop rmsRef = np.sqrt(np.mean(np.abs(signalRefChop)**2)) evmValue = 20 * np.log10( np.sqrt(np.mean(np.abs(np.abs(errorVector)**2))) / rmsRef) if (debugMode): print('rmsRef = ', rmsRef) fig6, (ax6a, ax6b) = plt.subplots(figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k', ncols=1, nrows=2, sharex=False) ax6aa = ax6a.twinx() ax6a.plot(signalInRot.real, 'r', label='Rot Real') ax6a.plot(signalRef.real, 'b--', label='Ref Real') ax6aa.plot(20 * np.log10(errorVector.real / rmsRef), 'k', label='Error') ax6aa.legend() ax6bb = ax6b.twinx() ax6b.plot(signalInRot.imag, 'r', label='Rot Imag') ax6b.plot(signalRef.imag, 'b--', label='Ref Imag') ax6bb.plot(20 * np.log10(errorVector.imag / rmsRef), 'k', label='Error') ax6bb.legend() ax6a.set_title(f'EVM = {evmValue}') plt.show() return (evmValue)
def main(): rrcos = rrcosfilter(NBAUDS * UPSAMPLE, ROLL_OFF, 1. / BAUD_RATE, SAMPLE_RATE)[1] rrcos = rrcos / np.sqrt(UPSAMPLE) rrcos_fixed = arrayFixedInt(COEF_NBITS, COEF_FBITS, rrcos) prbs_r = prbs(SEED_R) tx_r = tx(rrcos_fixed, UPSAMPLE, COEF_NBITS, COEF_FBITS, TX_NBITS, TX_FBITS) rx_r = rx(rrcos_fixed, UPSAMPLE, COEF_NBITS, COEF_FBITS, TX_NBITS, TX_FBITS) ber_r = ber(SEQ_LEN) rrcos_float = [i.fValue for i in rrcos_fixed] prbs_r_v = [] tx_r_v = [] rx_r_v = [] rx_full_v = [] prbs_r.reset() tx_r.reset() rx_r.reset() ber_r.reset() phase = DX_SWITCH_SEL prbs_r_s = prbs_r.prbs_out tx_r_s = tx_r.tx_out rx_r_s = rx_r.rx_out enable_prbs = 0 enable_tx = 1 enable_rx = 1 enable_ber = 0 counter = 0 for i in range(NCLK): prbs_r_s = prbs_r.prbs_out tx_r_s = tx_r.tx_out rx_r_s = rx_r.rx_out rx_full_out = rx_r.rx_full_out prbs_r_v.append(prbs_r_s) tx_r_v.append(tx_r_s.fValue) rx_r_v.append(rx_r_s) rx_full_v.append(rx_full_out.fValue) prbs_r.run(enable_prbs) ber_r.run(prbs_r_s, rx_r_s, enable_ber) rx_r.run(tx_r_s, phase, enable_rx) tx_r.run(prbs_r_s, enable_tx) if counter == 0: enable_prbs = 1 enable_ber = 1 else: enable_prbs = 0 enable_ber = 0 counter = (counter + 1) % 4 vector = zip(range(NCLK), prbs_r_v, tx_r_v, rx_full_v, rx_r_v) """ for i in vector[0:20]: print i exit() """ plt.figure() plt.grid() plt.plot(tx_r_v[:200]) plt.figure() plt.grid() plt.plot(rx_full_v[:200]) rx_a = arrayFixedInt(8, 7, rx_full_v[:200]) rx_a = [i.fValue for i in rx_a] plt.figure() plt.grid() plt.plot(rx_a) """ eyediagram(rx_full_v[12:], 4, 1, UPSAMPLE) rrcos_float = [i.fValue for i in rrcos_fixed] H,A,F = resp_freq(rrcos_float, 1./BAUD_RATE, 512) plt.figure() plt.grid() plt.semilogx(F, 20*np.log(H)) plt.figure() plt.grid() plt.plot([i.fValue for i in rrcos_fixed]) """ plt.show()
l = 0 for line in fileobject: reading = line[0:line.find(",")] raw_samples.append(complex(reading)) l = +1 fileobject.close() # print(raw_samples) #################Read From Textfile################## # set carrier frequency fsy = 100000 samplefreq = 2.4e6 fsymrate = 1.3e9 #+ fsy time, h_t = rrcosfilter(300000, 0.5, 1 / fsy, samplefreq) #h_t = h_t/np.max(h_t) #raw_samples = raw_samples/np.max(raw_samples) jaaaa = signal.fftconvolve((raw_samples), h_t, mode='full') #rawsquare = np.square(raw_samples) #mag = np.sqrt(jaaaa.real()**2 + jaaaa.imag()**2) jaaaa = jaaaa[15000:45000] #/np.max(jaaaa) t = np.arange(0, 30000 / samplefreq, 1 / samplefreq) clock = 0.5 * np.cos(fsy * 2 * np.pi * t + 25 * np.pi / 5) + .5 #vir DBPSK clock2 = 0.5 * np.cos(samplefreq * 2 * np.pi * time + 5 * np.pi / 5) + .5 #vir DBPSK no_zerosH = [] ons_sample_hier_jaH = np.zeros([300000], dtype=complex) flaggie = 0 ##################################################################Die issue is dalk hier
import numpy as np from random import randint from commpy.modulation import QAMModem from commpy.filters import rrcosfilter from commpy.utilities import bitarray2dec, dec2bitarray np.set_printoptions(threshold=np.nan) N = 1024 # output size M = 16 mod1 = QAMModem(M) # QAM16 sB = dec2bitarray(randint(0, 2**(mod1.num_bits_symbol * N * M / 4)), (mod1.num_bits_symbol * N * M / 4)) # Random bit stream # print np.array2string(sB) sQ = mod1.modulate(sB) # Modulated baud points print np.array2string(np.abs(sQ)) sPSF = rrcosfilter(N * 4, 0.2, 1, 4000)[1] qW = np.convolve(sPSF, sQ) # Waveform with PSF #print np.array2string(qW)