#phase offset
phi_off=np.random.random()*2*np.pi
phi_off=0
#number of Index bits per symbol
Ni=int(np.log2(SA))
#number of Data bits per symbol
Nd=int(np.log2(M))
#Upsampling rate
n_up=8
takt_off=np.random.randint(1,n_up)
#takt_off=0
print("takt_off=",takt_off)
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
K=7
filter_=rrcfilter(K*n_up+1,n_up , 1,1)
g=filter_.ir()
#Plot.timesignal(g,"g")
#Channel matrix
H=1/np.sqrt(2)*((np.random.randn(RA,SA))+1j/np.sqrt(2)*(np.random.randn(RA,SA)))
#H=np.array([[1-0.5*1j,1]])
#H=np.array([[0.5,0.1,-0.3j,0.2+0.8j]])
#H=np.array([[-0.3j,-0.3j,-0.3j,-0.3j]])
#H=np.ones([RA,SA])
f_est=[]
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#fl=FLL(g,n_up)
gardner=gardner_timing_recovery(n_up)
for i in range(0,1):
#sender
sender_=sender(N,N_known,Ni,Nd,mpsk_map,filter_,k)
def sm(SNR_dB,N,N_known,threshold):
#def sm(SNR_dB,n):
#number of sender antennas
SA=4
#number of receiver antennas
RA=4
#data bits modulation order (BPSK)
M=2
mpsk_map=np.array([1,-1])
#mpsk_map =1/np.sqrt(2) * np.array([1+1j, -1+1j, 1-1j, -1-1j], dtype=complex)
#symbol duration
T=1*1e-6
#Frequency offset
#f_off=np.random.randint(-0.001/T,0.001/T)
f_off=np.random.randint(0.01/T,0.05/T)
# N_known=int(1//T//f_off/n)
# N=10*N_known
#phase offset
phi_off=np.random.random()*2*np.pi
#number of Index bits per symbol
Ni=int(np.log2(SA))
#number of Data bits per symbol
Nd=int(np.log2(M))
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Upsampling rate
n_up=1
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
filter_=rrcfilter(8*n_up+1,n_up , 1,0.5)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Channel matrix
H=1/np.sqrt(2)*((np.random.randn(RA,SA))+1j/np.sqrt(2)*(np.random.randn(RA,SA)))
#H=np.ones([RA,SA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#sender
sender_=sender(N,N_known,Ni,Nd,mpsk_map,filter_)
#print("n_start=",sender_.n_start)
#training symbols(/bits) which may be shared with receiver, when a data-aided method is used
symbols_known=sender_.symbols_known
ibits=sender_.ibits
dbits=sender_.dbits
n_start=sender_.n_start
ibits_known=sender_.ibits_known
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with Filter(noch zu bearbeiten,überabtastung!)
receiver_=receiver(H,sender_,SNR_dB,filter_,mpsk_map)
receiver_.channel()
r_mf=receiver_.r_mf
#BER for perfect sync
yi,yd=receiver_.detector(r_mf,H)
BERi_0,BERd_0=test.BER(yi,yd,Ni,Nd,ibits,dbits)
#with offsets
off=np.exp(1j*2*np.pi*f_off*np.arange(r_mf.shape[0])*T/filter_.n_up)
r_off_ft=r_mf*np.repeat(off,RA).reshape([-1,RA])*np.exp(1j*phi_off)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#coarse Estimation for f_off (draft)
f_off_coarse=0
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#coarse synchronisation
off_syc=np.exp(-1j*2*np.pi*f_off_coarse*np.arange(r_mf.shape[0])*T/filter_.n_up)
r_syc_coarse=r_off_ft*np.repeat(off_syc,RA).reshape([-1,RA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Sampling Clock Synchronization
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Joint Estimation for f_off,n_start and CSI
j=joint_estimation()
j.function(r_syc_coarse,N,N_known,T,ibits_known,symbols_known,SA,RA)
f_est=j.f_est
n_est=j.n_est
H_est=j.H_est
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Synchronisation
off_syc=np.exp(-1j*2*np.pi*f_est*(np.arange(r_mf.shape[0]))*T)
r_f_syc=r_syc_coarse*np.repeat(off_syc,RA).reshape([-1,RA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Detection and BER Test
yi,yd=receiver_.detector(r_f_syc,H_est)
#yi,yd=rr.detector(H_est,SNR_dB,mpsk_map,r_ft_syc)
BERi,BERd=test.BER(yi,yd,Ni,Nd,ibits,dbits)
#
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#
#if BERi<=threshold and BERd<=threshold and n_start==n_est:
if n_start==n_est:
count=1
else:
count=0
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
return count
def sm(SNR_dB):
fc = 1 * 1e9 # LTE
offset_range = 40 * 1e-6
#print("f_max=",fc*offset_range)
#number of sender antennas
SA = 2
#number of receiver antennas
RA = 1
#data bits modulation order (BPSK)
M = 2
mpsk_map = np.array([1, -1])
#mpsk_map =1/np.sqrt(2) * np.array([1+1j, -1+1j, 1-1j, -1-1j], dtype=complex)
#mpsk_map =1/np.sqrt(2) * np.array([1, 1j, -1j, -1], dtype=complex)
#number of symbols per Frames
Ns = 2
#number of Frames
Nf = 100
#number of symbols
N = Ns * Nf
#number of training symbols
N_known = 64 * 4
N = N_known * 2
k = 8
#symbol duration
T = 1 * 1e-6
#print("f_vernachlaessigbar=",0.01/N/T)
#T=1
#Frequency offset
f_off = np.random.randint(-fc * offset_range, fc * offset_range) * 0.1
#f_off=np.random.randint(-0.01/T,0.01/T)
#N_known=int(1//T//f_off/4)
#N=10*N_known
# print("f_off=",f_off)
#symbol offset
#n_off=2
#phase offset
phi_off = np.random.random() * 2 * np.pi
phi_off = 0
#number of Index bits per symbol
Ni = int(np.log2(SA))
#number of Data bits per symbol
Nd = int(np.log2(M))
#Upsampling rate
n_up = 2
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
K = 20
filter_ = rrcfilter(K * n_up + 1, n_up, 1, 0.5)
g = filter_.ir()
#Plot.spectrum(g,"g")
#Channel matrix
H = 1 / np.sqrt(2) * ((np.random.randn(RA, SA)) + 1j / np.sqrt(2) *
(np.random.randn(RA, SA)))
#H=np.array([[0.5,0.1]])
H = np.ones([RA, SA])
MSE_n = []
MSE_f = []
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
tries = 200
for i in range(0, tries):
#sender
sender_ = sender(N, N_known, Ni, Nd, mpsk_map, filter_, k)
# print("n_start=",sender_.n_start,sender_.n_start*n_up,(sender_.n_start+N_known)*n_up)
#training symbols(/bits) which may be shared with receiver, when a data-aided method is used
symbols_known = sender_.symbols_known
#symbols_known=ss
symbols = sender_.symbols
ibits = sender_.ibits
# dbits=sender_.dbits
ibits_known = sender_.ibits_known
index = bitarray2dec(ibits_known)
# dbits_known=sender_.dbits_known
s_BB = sender_.bbsignal()
group_delay = (g.size - 1) // 2
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with Filter
receiver_ = receiver(H, sender_, SNR_dB, filter_, mpsk_map)
r = receiver_.r
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#with offsets
#Frequency offset before MF(+filter length)
#!!!T anpassen!!!
off = np.exp(1j * 2 * np.pi * f_off *
np.arange(sender_.bbsignal().size) * T / n_up)
r = receiver_.r * np.repeat(off, RA).reshape([-1, RA])
r_mf = receiver_.Matched_Filter(
r.real) + 1j * receiver_.Matched_Filter(r.imag)
r_mf = r_mf[2 * group_delay:-2 * group_delay]
#%%%%%%%%%%%%%%%%%
#Modified Delay Correlation
f_est, n_est, M = DC(r_mf, T, symbols_known, n_up, N_known, k)
# print("n_est=",n_est)
##
# print("f_est=",f_est)
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#Frequency synchronisation
# y=r_mf*np.exp(-1j*2*np.pi*f_off*(np.arange(r_mf.shape[0])+2*group_delay)*T/n_up).reshape([-1,RA])
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
##MSE
# MSE_n.append((sender_.n_start-n_est)**2)
# MSE_f.append((f_off-f_est)**2)
MSE_n.append((sender_.n_start - n_est))
MSE_f.append((f_off - f_est) / f_off)
return np.average(MSE_n), np.average(MSE_f)
#Frequency offset
f_off = np.random.randint(0, 1 * 1e-2 / T)
print("f_off=", f_off)
#symbol offset
#n_off=2
#phase offset
phi_off = np.random.random() * 2 * np.pi
phi_off = 0
#number of Index bits per symbol
Ni = int(np.log2(SA))
#number of Data bits per symbol
Nd = int(np.log2(M))
#Upsampling rate
n_up = 1
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
filter_ = rrcfilter(8 * n_up + 1, n_up, 1, 0)
#Channel matrix
H = 1 / np.sqrt(2) * ((np.random.randn(RA, SA)) + 1j / np.sqrt(2) *
(np.random.randn(RA, SA)))
#H=np.ones([RA,SA])
#sender
sender_ = sender(N, N_known, Ni, Nd, mpsk_map, filter_)
print("n_start=", sender_.n_start)
#training symbols(/bits) which may be shared with receiver, when a data-aided method is used
symbols_known = sender_.symbols_known
ibits = sender_.ibits
dbits = sender_.dbits
ibits_known = sender_.ibits_known
dbits_known = sender_.dbits_known
def sm(n_up):
SNR_noise_dB = 30
SNR_RA_dB = 0
SA = 16
#number of sender antennas
RA = 16
#number of receiver antennas
M = 2
#data bits modulation order (BPSK)
mpsk_map = np.array([1, -1])
#mpsk_map =1/np.sqrt(2) * np.array([1+1j, 1+1j, 1-1j, -1-1j], dtype=complex)
N = 50
#number of symbols
T = 1 * 1e-6
#symbol duration
f_off = 0
n_off = 5
phi_off = 0
#number of training symbols
Ni = int(np.log2(SA))
#number of Index bits per symbol
Nd = int(np.log2(M))
#number of Data bits per symbol
#n_up=8
filter_ = rrcfilter(8 * n_up + 1, n_up, 1, 0)
# RRC Filter (L=K * sps + 1, sps, t_symbol, rho)
#???? BER fuer Index verschlechtet sich bei Uebungabtastung
# besser mit rho=1
H = 1 / np.sqrt(2) * ((np.random.randn(RA, SA)) + 1j / np.sqrt(2) *
(np.random.randn(RA, SA)))
#H=np.abs(H)
#Channel matrix
#H=np.ones([RA,SA])
#H_est=H.real*0.9+1j*H.imag*1.1
sender_ = sender(N, Ni, Nd, mpsk_map, filter_)
#tx
s = sender_.bbsignal()
#r_off=s
#training symbols(/bits) which may be shared with receiver, when a data-aided method is used
symbols = sender_.symbols
ibits = sender_.ibits
dbits = sender_.dbits
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
##with Filter(noch zu bearbeiten,überabtastung!)
#receiver_=receiver(H,sender_,SNR_noise_dB,SNR_RA_dB,filter_,mpsk_map)
#r=receiver_.channel()
#r_mf=receiver_.r_mf
##yi=receiver_.yi
##yd=receiver_.yd
#yi,yd=receiver_.detector(r_mf,H)
#BERi_0,BERd_0=test.BER(yi,yd,Ni,Nd,ibits,dbits)
#
#
##with offsets
##Frequency offset before MF(+filter length)
##off=np.exp(1j*2*np.pi*f_off*np.arange(sender_.bbsignal().size)*T/filter_.n_up)
##r=receiver_.channel()*np.repeat(off,RA).reshape([-1,RA])
##r_mf=receiver_.Matched_Filter(r.real)+1j*receiver_.Matched_Filter(r.imag)
##offset after MF
#
#r=receiver_.channel()
#r_mf=receiver_.Matched_Filter(r.real)+1j*receiver_.Matched_Filter(r.imag)
#off=np.exp(1j*2*np.pi*f_off*np.arange(r_mf.shape[0])*T/filter_.n_up)
#
##test
#rrr=np.concatenate((r_mf[n_off:],r_mf[:n_off]))
##
#r_m=r_mf*np.exp(1j*2*np.pi*phi_off)*np.repeat(off,RA).reshape([-1,RA])
#r_off_ft=np.concatenate((r_m[n_off:],r_m[:n_off]))
#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#without Filter
#noise_variance_linear = 10**(-SNR_noise_dB / 10)
#s_a_index=np.repeat(bitarray2dec(ibits),n_up)
#rx=np.zeros((symbols.size,H.shape[0]),complex)
#for j in range(0,H.shape[0]):
# for i in range(0,s_a_index.size):
# n = np.sqrt(noise_variance_linear / 2) * (np.random.randn(symbols.size)+1j*np.random.randn(symbols.size) )
# rx[i,j]=np.sqrt(10**(SNR_RA_dB / 10))*symbols[i]*H[j,s_a_index[i]]
# rx[:,j]=rx[:,j]+n
receiver_ = receiver(H, sender_, SNR_noise_dB, filter_, mpsk_map)
rx = receiver_.channel_nf(n_up)
yi, yd = receiver_.detector(rx, H)
BERi_0, BERd_0 = test.BER(yi, yd, Ni, Nd, ibits, dbits)
return BERi_0, BERd_0