def get_pulseshaped_data(self, num, mod, os, length=None, alpha=0.35):
""" generates random, oversampled and root-raised cosine filtered data
INPUT:
num:
mod:
os: oversampling factor
length: length of the rc filter
alpha: roll-off factor
Ts: symbol period
Fs: sampling rate
OUTPUT: (data_raw, data_mod, data_shaped)
data_raw: integer valued np.array with raw (binary) data
data_mod: complex valued np.array with modulated data
data_os: complex valued np.array with oversampled data
data_shaped: complex valued np.array with pulse-shaped data
rc: coefficients of the RC filter
"""
# empirical values
Ts = 8e-6
Fs = 2 * 0.625e5 * os
length = 8 * os if length == None else length
data_raw, data_mod = self.get_random_data(num, mod)
rc = rcosfilter(length, alpha, Ts, Fs)[1]
os_filter = np.zeros(os)
os_filter[0] = 1
data_os = np.kron(data_mod, os_filter)
# center ramp up and ramp down of filter
data_os = np.concatenate([np.zeros(os / 2), data_os[:-os / 2]])
data_shaped = np.convolve(rc, data_os)
# center the filter
data_shaped = data_shaped[length / 2:-length / 2 + 1]
return (data_raw, data_mod, data_os, data_shaped, rc)
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 lowpass_filter(i, q, numtaps, cutoff, N, Ts, Fs, alpha=0.35):
h = firwin(numtaps, cutoff, nyq=float(self.carrier_freq / 2))
i, q = lfilter(h, 1.0, i), lfilter(h, 1.0, q)
sPSF = rcosfilter(N, alpha, Ts, Fs)[1]
i, q = np.convolve(sPSF, i, mode='same'), np.convolve(sPSF,
q,
mode='same')
return i, q
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()