cc.m

A Novel Coded Layered Space-Time- Frequency Architecture: Convolutional Codes

function zbc
%Program-1 Main program of LSTF-c
global Nc ifftsize Tg Tb Ts T_sample guardtime Nd rate ifftsize dopplertf power_ratio alpha_freq pilot_position;
global M_ant N_ant lou llr_appro_flag fd L int_flag rate E_chipsymb ch_est_flag;
global modu_size Modulate_map Modulate_map_real Modulate_map_imag nEN;
global Max_delay Dexp Dexp_point fs Multipath_E Multipath_amp S_1_2 R_1_2 pilot symbol2bit feedback_flag tail_flag;
global bin_state next_state next_state_code1 next_state_code2 last_state;
M_ant = 4;
N_ant = 4;
Nc = 384;
ifftsize = 512;
Tg = 1.674; % as usecond.
Tb = 7.585; % as usecond.
Ts = Tb+Tg;
T_sample = Tb/ifftsize;
guardtime = round(Tg/T_sample);
Nd = 24;
fs = 1/T_sample*1e6/(ifftsize+guardtime); % T_sample is usecond.
ch_est_flag = fscanf(fid,'%d',1);%(0:ideal,1:no ideal/default:1)
alpha_freq = fscanf(fid,'%f',3);
pilot_position = fscanf(fid,'%d',1);%(0:head,1:middle,2:tail)
LLR_EIR_flag = fscanf(fid,'%d',1);%(0:LLR,1:EIR/default:0)
clip_value = fscanf(fid,'%d',1);%(default:30);
feedback_flag = fscanf(fid,'%d',1);%(0:ideal feedback,1:non-ideal feedback);
niter_loop = fscanf(fid,'%d',1);
if feedback_flag == 0
niter_loop = 1;
end
lou = fscanf(fid,'%f',1);
len_Eb_N0 = fscanf(fid,'%d',1);
snr_b = fscanf(fid,'%f',len_Eb_N0);
gama = fscanf(fid,'%f',1);
[power_ratio, Eb_N0_dB] = get_Eb_N0_dB(snr_b,gama);
num_frames = fscanf(fid,'%d',len_Eb_N0);
fd = fscanf(fid,'%f',1);
L = fscanf(fid,'%d',1);
Max_delay = fscanf(fid,'%f',1);
dopplertf = doptf(fd,fs);
modu_size = 2;
Modulate_map = [-1+i,-1-i,1+i,1-i];
Modulate_map_real = [-1, 1];
Modulate_map_imag = [i, -i];
symbol2bit = [0 0;0 1;1 0;1 1];
E_chipsymb = 2;
rate = 1/2;
tail_flag = 0;
my_n = modu_size*Nd*Nc;
my_k = my_n*1/2;
puncture = [1:my_n];
g = [1 0 0 1 1;1 1 1 0 1]; %(23,35), v = 4
for indx1 = 1:M_ant
for indx2 = 1:M_ant
for indx3 = 1:Nc
for indx4 = 1:Nd/M_ant
indx_int_a = (indx3-1)*Nd+mod(indx3-1+indx2-1+indx1-1,M_ant)+1+(indx4-1)*M_ant;
mult_pattern((indx1-1)*Nd*Nc+indx_int_a) = (indx1-1)*Nd*Nc/M_ant+(indx2-1)*Nd*Nc+(indx3-1)*Nd/M_ant+indx4;
end
114
end
end
end
pilot_pattern = eye(M_ant);
for indx1 = 1:M_ant
pilot_temp(:,:,indx1) = sqrt(power_ratio*E_chipsymb)*ones(Nc,1)*pilot_pattern(indx1,:);
end
pilot = permute(pilot_temp,[3,1,2]);
errs_bits_encoded = zeros(length(Eb_N0_dB),niter_loop);
errs_bits = zeros(length(Eb_N0_dB),niter_loop);
errs_codewords = zeros(length(Eb_N0_dB),niter_loop);
errs_packets = zeros(length(Eb_N0_dB),niter_loop);
for nEN = 1:length(Eb_N0_dB)
en = 10^(Eb_N0_dB(nEN)/10);
Eb = Ts/Tb*E_chipsymb/modu_size;
sigma = sqrt(Eb/(2*en*rate));
for test = 1:num_frames(nEN)
% encoder:
x = (sign(sign(randn(1,my_k*M_ant))+0.1)+1)/2;
y = [];
for m = 1:M_ant
[temp,myalpha((m-1)*my_n+1:m*my_n)] = sort(rand(1,my_n));
x(m*my_k-size(g,2)+2:m*my_k) = tail_flag*x(m*my_k-size(g,2)+2:m*my_k);
y_temp1 = encode_conv(g,x((m-1)*my_k+1:m*my_k));
y_temp2 = y_temp1(puncture);
y = [y,y_temp2(myalpha((m-1)*my_n+1:m*my_n))];
end
myalpha_whole = [myalpha+kron([0:M_ant-1]*my_n,ones(1,my_n))];
% modulation:
symbol = symbol_modulation(y);
% multiplex to antennas:
symbol_temp = permute(reshape(symbol(mult_pattern),Nd,Nc,M_ant),[3,2,1]);
if pilot_position == 0
symbol_ofdm_MIMO = cat(3,pilot,symbol_temp);
elseif pilot_position == 1
symbol_ofdm_MIMO = cat(3,symbol_temp(:,:,1:Nd/2),pilot,symbol_temp(:,:,Nd/2+1:Nd));
else
symbol_ofdm_MIMO = cat(3,symbol_temp,pilot);
end
[R,channel_ideal] = OFDM_channel(symbol_ofdm_MIMO,sigma);
L_E = zeros(1,M_ant*my_n);
iter = 0;
err_packets = 1e300;
while ((err_packets ~= 0) & (iter < niter_loop)),
iter = iter+1;
L_E = L_E(myalpha_whole);
for indx = 1:modu_size
L_A1(indx+([1:Nc*Nd*M_ant]-1)*modu_size) = L_E(indx+(mult_pattern-1)*modu_size);
end
L_A1(find(L_A1<-clip_value)) = -clip_value;
L_A1(find(L_A1> clip_value)) = clip_value;
L_D1 =demodulation(R,channel_ideal,sigma,permute(reshape(L_A1,modu_size*Nd,Nc,M_ant),[3,2,1]),symbol_temp);
for indx = 1:modu_size
L_D1(indx+(mult_pattern-1)*modu_size) = L_D1(indx+([1:Nc*Nd*M_ant]-1)*modu_size);
end
demo_bits = (1-sign(L_D1))/2;
L_A2(myalpha_whole) = L_D1;
L_A2(find(L_A2<-clip_value)) = -clip_value;
L_A2(find(L_A2> clip_value)) = clip_value;
f1 = 1./(1+exp(L_A2));
f0 = 1-f1;
for m = 1:M_ant
115
L_A2_temp = zeros(1,my_k*size(g,1));
L_A2_temp(puncture) = L_A2((m-1)*my_n+1:m*my_n);
[x_hat((m-1)*my_k+1:m*my_k),L_D2_temp] = logmap(L_A2_temp,g);
L_D2((m-1)*my_n+1:m*my_n) = L_D2_temp(puncture);
err_codewords = sign(length(find(x_hat((m-1)*my_k+1:m*my_k) ~= x((m-1)*my_k+1:m*my_k))));
errs_codewords(nEN,iter) = errs_codewords(nEN,iter)+err_codewords;
end
err_bits_encoded = length(find(demo_bits ~= y));
err_bits = length(find(x_hat ~= x));
err_packets = sign(err_bits);
errs_bits_encoded(nEN,iter) = errs_bits_encoded(nEN,iter)+err_bits_encoded;
errs_bits(nEN,iter) = errs_bits(nEN,iter)+err_bits;
errs_packets(nEN,iter) = errs_packets(nEN,iter)+err_packets;
L_E = L_D2-L_A2*LLR_EIR_flag;
end % iter
fprintf('%d ',test);%fprintf('\n');
end % test
ber_bits_encoded(nEN,1:niter_loop) = errs_bits_encoded(nEN,1:niter_loop)/num_frames(nEN)/my_n/M_ant;
ber_bits(nEN,1:niter_loop) = errs_bits(nEN,1:niter_loop)/num_frames(nEN)/my_k/M_ant;
ber_codewords(nEN,1:niter_loop) = errs_codewords(nEN,1:niter_loop)/num_frames(nEN)/M_ant;
ber_packets(nEN,1:niter_loop) = errs_packets(nEN,1:niter_loop)/num_frames(nEN);
fprintf('\n************** Eb/N0 = %5.2f db **************\n', Eb_N0_dB(nEN));
fprintf('Encoded bit,data bit,codeword,and packet error rate:\n');
fprintf('%d-th ', [1:niter_loop]);
fprintf('iteration:\n\n');
fprintf('%8.4f ', ber_bits_encoded(nEN,1:niter_loop));
fprintf('\n');
fprintf('%8.4f ', ber_bits(nEN,1:niter_loop));
fprintf('\n');
fprintf('%8.4f ', ber_codewords(nEN,1:niter_loop));
fprintf('\n');
fprintf('%8.4f ', ber_packets(nEN,1:niter_loop));
fprintf('\n');
fprintf('***********************************************\n\n');
end
%Program-2 Symbol modulation in transmitter
function symbol = symbol_modulation(bit_stream)
global Nc ifftsize Tg Tb Ts T_sample guardtime Nd rate ifftsize;
global M_ant N_ant lou decoder_flag fd L int_flag rate E_chipsymb;
global modu_size Modulate_map Modulate_map_real Modulate_map_imag nEN;
global Max_delay Dexp Dexp_point fs Multipath_E Multipath_amp S_1_2 R_1_2 pilot;
global symbol2bit;
num_symbol = length(bit_stream)/modu_size;
symbol_temp = reshape(bit_stream,modu_size,num_symbol);
index_real = 1+sum(2.^kron((modu_size/2-1:-1:0)',ones(1,num_symbol)).*symbol_temp(1:2:modu_size-1,1:num_symbol),1);
index_imag = 1+sum(2.^kron((modu_size/2-1:-1:0)',ones(1,num_symbol)).*symbol_temp(2:2:modu_size,1:num_symbol),1);
symbol = Modulate_map_real(index_real)+Modulate_map_imag(index_imag);
%Program-3 Multipath channel Model
function [R,H_ideal] = OFDM_channel(symbol_ofdm_MIMO,sigma)
global Nc ifftsize Tg Tb Ts T_sample guardtime Nd rate ifftsize;
global M_ant N_ant lou llr_appro_flag fd L int_flag rate E_chipsymb ch_est_flag;
global modu_size Modulate_map Modulate_map_real Modulate_map_imag nEN;
global Max_delay Dexp Dexp_point fs Multipath_E Multipath_amp S_1_2 R_1_2 pilot;
global symbol2bit;
global dopplertf;
length_symbol = size(symbol_ofdm_MIMO,3);
if L == 1
116
Max_delay = 0;
Dexp = 0;
Dexp_point = 0;
else
Dexp = Max_delay/(L-1);
Dexp_point = round(Dexp/T_sample);
end
fs = 1/T_sample*1e6/(ifftsize+guardtime); % T_sample is usecond.
% For multipath profile:
Multipath_E(1) = 1;
for l = 2:L
Multipath_E(l) = Multipath_E(l-1)*10^(-1.2/L); %exponential decay of average power.
end
Multipath_amp = (Multipath_E/sum(Multipath_E)).^0.5;
S = lou*ones(M_ant,M_ant)+(1-lou)*eye(M_ant);
S_1_2 = sqrtm(S);
R_my = lou*ones(N_ant,N_ant)+(1-lou)*eye(N_ant);
R_1_2 = sqrtm(R_my);
if fd == 0
for l = 1:L
for n = 1:N_ant % number of receiver antenna
for m = 1:M_ant % number of transmitter antenna
H_w_l(n,m,l,1:length_symbol) = Multipath_amp(l)*(randn+i*randn)/sqrt(2)*ones(1,length_symbol);
end
end
for sym_index = 1:length_symbol
H_l(:,:,l,sym_index) = R_1_2*H_w_l(:,:,l,sym_index)*S_1_2;
end
end
else
for l = 1:L
for n = 1:N_ant % number of receiver antenna
for m = 1:M_ant % number of transmitter antenna
my_rayleigh = flatfade(fd,fs,1/fs*10000,dopplertf,0);
H_w_l(n,m,l,1:length_symbol) = Multipath_amp(l)*my_rayleigh(9900+1:9900+length_symbol);
end
end
for sym_index = 1:length_symbol
H_l(:,:,l,sym_index) = R_1_2*H_w_l(:,:,l,sym_index)*S_1_2;
end
end
end
for n = 1:N_ant % number of receiver antenna
for k = 1:Nc
noise_array(n,k,1:length_symbol) = sigma*(randn(1,length_symbol)+randn(1,length_symbol)*i)/sqrt(2);
end
for m = 1:M_ant % number of transmitter antenna
Multipath_t_domain = zeros(ifftsize,length_symbol);
if L == 1
Multipath_t_domain(1,:) = (squeeze(H_l(n,m,1,:))).';
else
temp = zeros(Dexp_point,1);
temp(1,1) = 1;
Multipath_t_domain(1:L*Dexp_point,1:length_symbol) = kron(squeeze(H_l(n,m,:,:)),temp);
end
for sym_index = 1:length_symbol
H_temp(1:ifftsize,sym_index) = fft(Multipath_t_domain(:,sym_index));
end
H_ideal(:,:,n,m) = H_temp(1:Nc,1:length_symbol);
R_temp(:,:,n,m) = squeeze(H_ideal(:,:,n,m)).*squeeze(symbol_ofdm_MIMO(m,:,:));
end
R(:,:,n) = squeeze(sum(R_temp(:,:,n,:),4))+squeeze(noise_array(n,:,:));
end
H_ideal = permute(H_ideal,[3,4,1,2]);
R = permute(R,[3,1,2]);
117
%Program-4 Soft detector & channel estimation in the receiver
function L_D = demodulation(R,H_ideal,sigma,L_A,symbol_data)
global Nc ifftsize Tg Tb Ts T_sample guardtime Nd rate ifftsize;
global M_ant N_ant lou llr_appro_flag fd L int_flag rate E_chipsymb ch_est_flag;
global modu_size Modulate_map Modulate_map_real Modulate_map_imag nEN;
global Max_delay Dexp Dexp_point fs Multipath_E Multipath_amp S_1_2 R_1_2 pilot;
global symbol2bit;
global feedback_flag;