fix_1_soft1664qam 44.txt

详细的空时分组码程序

mult_tempt(1,13)+mult_tempt(1,14)+...
mult_tempt(1,15)+mult_tempt(1,16))/st2/2^tempt_eff);
decode_tempt_r(1,3) = decode_tempt_r(1,3)+sum_tempt;

mult_tempt(1,1) = -rec_code_r(1,r,n)*ch_mul_noice_i(3,r,n);
mult_tempt(1,2) = rec_code_i(1,r,n)*ch_mul_noice_r(3,r,n);
mult_tempt(1,3) = -rec_code_r(2,r,n)*ch_mul_noice_i(3,r,n);
mult_tempt(1,4) = rec_code_i(2,r,n)*ch_mul_noice_r(3,r,n);
mult_tempt(1,5) = -rec_code_r(1,r,n)*ch_mul_noice_i(4,r,n);
mult_tempt(1,6) = rec_code_i(1,r,n)*ch_mul_noice_r(4,r,n);
mult_tempt(1,7) = rec_code_r(2,r,n)*ch_mul_noice_i(4,r,n);
mult_tempt(1,8) = -rec_code_i(2,r,n)*ch_mul_noice_r(4,r,n);
mult_tempt(1,9) = rec_code_r(3,r,n)*ch_mul_noice_i(1,r,n);
mult_tempt(1,10) = -rec_code_i(3,r,n)*ch_mul_noice_r(1,r,n);
mult_tempt(1,11) = rec_code_r(3,r,n)*ch_mul_noice_i(2,r,n);
mult_tempt(1,12) = -rec_code_i(3,r,n)*ch_mul_noice_r(2,r,n);
mult_tempt(1,13) = rec_code_r(4,r,n)*ch_mul_noice_i(1,r,n);
mult_tempt(1,14) = -rec_code_i(4,r,n)*ch_mul_noice_r(1,r,n);
mult_tempt(1,15) = -rec_code_r(4,r,n)*ch_mul_noice_i(2,r,n);
mult_tempt(1,16) = rec_code_i(4,r,n)*ch_mul_noice_r(2,r,n);
for nnn = 1:16
if mult_tempt(1,nnn) >= Max_add_value 
mult_tempt(1,nnn) = Max_add_value-1;
mult_flow_num = mult_flow_num+1;
elseif mult_tempt(1,nnn) < -Max_add_value
mult_tempt(1,nnn) = -Max_add_value;
mult_flow_num = mult_flow_num+1;
end
end
sum_tempt = fix((mult_tempt(1,1)+mult_tempt(1,2) +...
mult_tempt(1,3)+mult_tempt(1,4)+...
mult_tempt(1,5)+mult_tempt(1,6)+...
mult_tempt(1,7)+mult_tempt(1,8)+...
mult_tempt(1,9)+mult_tempt(1,10) +...
mult_tempt(1,11)+mult_tempt(1,12)+...
mult_tempt(1,13)+mult_tempt(1,14)+...
mult_tempt(1,15)+mult_tempt(1,16))/st2/2^tempt_eff);
decode_tempt_i(1,3) = decode_tempt_i(1,3)+sum_tempt;
%***************************************************************************************
%***************************************************************
%***************
% if r == Rx_num -1 % 因为是累加操作所以溢出一般是在最后一次加法操作中出现
% tempt_eff = scale_eff;
% for nnn = 1:3
% decode_tempt_r(1,nnn) = fix(decode_tempt_r(1,nnn)/2^tempt_eff);
% decode_tempt_i(1,nnn) = fix(decode_tempt_i(1,nnn)/2^tempt_eff);
% end
% end
end % r = 1:Rx_num 
scale = 2^4;
decode_tempt_r(1,1) = fix(decode_tempt_r(1,1)*max_rec_sig/Max_value)*scale;
decode_tempt_r(1,2) = fix(decode_tempt_r(1,2)*max_rec_sig/Max_value)*scale;
decode_tempt_r(1,3) = fix(decode_tempt_r(1,3)*max_rec_sig/Max_value)*scale;
decode_tempt_i(1,1) = fix(decode_tempt_i(1,1)*max_rec_sig/Max_value)*scale;
decode_tempt_i(1,2) = fix(decode_tempt_i(1,2)*max_rec_sig/Max_value)*scale;
decode_tempt_i(1,3) = fix(decode_tempt_i(1,3)*max_rec_sig/Max_value)*scale;
Max_value2 = 2^13;
if decode_tempt_r(1,1) >= Max_value2 
decode_tempt_r(1,1) = Max_value2-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_r(1,1) < -Max_value2
decode_tempt_r(1,1) = -Max_value2;
add_flow_num = add_flow_num+1;
end
if decode_tempt_i(1,1) >= Max_value2 
decode_tempt_i(1,1) = Max_value2-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_i(1,1) < -Max_value2
decode_tempt_i(1,1) = -Max_value2;
add_flow_num = add_flow_num+1;
end 
if decode_tempt_i(1,2) >= Max_value2 
decode_tempt_i(1,2) = Max_value2-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_i(1,2) < -Max_value2
decode_tempt_i(1,2) = -Max_value2;
add_flow_num = add_flow_num+1;
end 
if decode_tempt_r(1,2) >= Max_value2 
decode_tempt_r(1,2) = Max_value2-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_r(1,2) < -Max_value2
decode_tempt_r(1,2) = -Max_value2;
add_flow_num = add_flow_num+1;
end
if decode_tempt_r(1,3) >= Max_value2 
decode_tempt_r(1,3) = Max_value2-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_r(1,3) < -Max_value2
decode_tempt_r(1,3) = -Max_value2;
add_flow_num = add_flow_num+1;
end 
if decode_tempt_i(1,3) >= Max_value2 
decode_tempt_i(1,3) = Max_value2-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_i(1,3) < -Max_value2
decode_tempt_i(1,3) = -Max_value2;
add_flow_num = add_flow_num+1;
end 

ch_sum = 0;
for n1 = 1:Tx_num*Rx_num
ch_sum = ch_sum + m(n1)*m(n1)';
end
ch_sum = fix(ch_sum*max_ch_est/2^(scale_eff-2)/Max_value);
Max_value3 = 2^10;
if ch_sum >= Max_value3
ch_sum = Max_value3-1;
add_flow_num = add_flow_num+1;
elseif ch_sum < -Max_value3
ch_sum = -Max_value3;
add_flow_num = add_flow_num+1;
end 
% decode_tempt_r(1,1) = fix(decode_tempt_r(1,1)/ch_sum/8*Max_value);
% decode_tempt_r(1,2) = fix(decode_tempt_r(1,2)/ch_sum/8*Max_value);
% decode_tempt_r(1,3) = fix(decode_tempt_r(1,3)/ch_sum/8*Max_value);
% decode_tempt_i(1,1) = fix(decode_tempt_i(1,1)/ch_sum/8*Max_value);
% decode_tempt_i(1,2) = fix(decode_tempt_i(1,2)/ch_sum/8*Max_value);
% decode_tempt_i(1,3) = fix(decode_tempt_i(1,3)/ch_sum/8*Max_value);

scale = 3;
if Mod_type == 6
ratio = 127/138; 
elseif Mod_type ==4
ratio = 1;
end
decode_tempt_r(1,1) = fix(decode_tempt_r(1,1)/ch_sum*2^(Max_bit_num-scale)*ratio);
decode_tempt_r(1,2) = fix(decode_tempt_r(1,2)/ch_sum*2^(Max_bit_num-scale)*ratio);
decode_tempt_r(1,3) = fix(decode_tempt_r(1,3)/ch_sum*2^(Max_bit_num-scale)*ratio);
decode_tempt_i(1,1) = fix(decode_tempt_i(1,1)/ch_sum*2^(Max_bit_num-scale)*ratio);
decode_tempt_i(1,2) = fix(decode_tempt_i(1,2)/ch_sum*2^(Max_bit_num-scale)*ratio);
decode_tempt_i(1,3) = fix(decode_tempt_i(1,3)/ch_sum*2^(Max_bit_num-scale)*ratio);

%-------------------译码输出（8bits）---------------------------%
if decode_tempt_r(1,1) >= Max_value 
decode_tempt_r(1,1) = Max_value-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_r(1,1) < Min_value
decode_tempt_r(1,1) = Min_value;
add_flow_num = add_flow_num+1;
end
if decode_tempt_i(1,1) >= Max_value 
decode_tempt_i(1,1) = Max_value-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_i(1,1) < Min_value
decode_tempt_i(1,1) = Min_value;
add_flow_num = add_flow_num+1;
end 
if decode_tempt_i(1,2) >= Max_value 
decode_tempt_i(1,2) = Max_value-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_i(1,2) < Min_value
decode_tempt_i(1,2) = Min_value;
add_flow_num = add_flow_num+1;
end 
if decode_tempt_r(1,2) >= Max_value 
decode_tempt_r(1,2) = Max_value-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_r(1,2) < Min_value
decode_tempt_r(1,2) = Min_value;
add_flow_num = add_flow_num+1;
end
if decode_tempt_r(1,3) >= Max_value 
decode_tempt_r(1,3) = Max_value-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_r(1,3) < Min_value
decode_tempt_r(1,3) = Min_value;
add_flow_num = add_flow_num+1;
end 
if decode_tempt_i(1,3) >= Max_value 
decode_tempt_i(1,3) = Max_value-1;
add_flow_num = add_flow_num+1;
elseif decode_tempt_i(1,3) < Min_value
decode_tempt_i(1,3) = Min_value;
add_flow_num = add_flow_num+1;
end

if Mod_type == 4
star_index_length = 16;
tempt_table = table16;
elseif Mod_type == 6
star_index_length = 64;
tempt_table = table64;
end
for star_index = 1:star_index_length 
star_r = fix(real(tempt_table(star_index)));
star_i = fix(imag(tempt_table(star_index)));

compare_tempt(1,1) = (decode_tempt_r(1,1)-star_r)^2+(decode_tempt_i(1,1)-star_i)^2;
compare_tempt(2,1) = (decode_tempt_r(1,2)-star_r)^2+(decode_tempt_i(1,2)-star_i)^2; 
compare_tempt(3,1) = (decode_tempt_r(1,3)-star_r)^2+(decode_tempt_i(1,3)-star_i)^2;

if star_index==1
compare_tempt(1,2) = compare_tempt(1,1);
compare_tempt(2,2) = compare_tempt(2,1); 
compare_tempt(3,2) = compare_tempt(3,1);
result_index(1) = star_index;
result_index(2) = star_index;
result_index(3) = star_index;
else
if compare_tempt(1,1) < compare_tempt(1,2)
compare_tempt(1,2) = compare_tempt(1,1);
result_index(1) = star_index;
end
if compare_tempt(2,1) < compare_tempt(2,2)
compare_tempt(2,2) = compare_tempt(2,1);
result_index(2) = star_index;
end
if compare_tempt(3,1) < compare_tempt(3,2)
compare_tempt(3,2) = compare_tempt(3,1);
result_index(3) = star_index;
end 
end % star_index==1
end % star_index = 1:star_index_length
decode_out(1,n) = tempt_table(result_index(1));
decode_out(2,n) = tempt_table(result_index(2));
decode_out(3,n) = tempt_table(result_index(3));
demap_int(1,n) = result_index(1)-1;
demap_int(2,n) = result_index(2)-1;
demap_int(3,n) = result_index(3)-1;
end % n = 1:Bits 
%------------------------qam 解调-------------------------------------------%
demap_out = zeros(Tx_num,pqam_length);
for t = 1:Tx_num-1
tempt = dec2bin(demap_int(t,:),Mod_type);
for n = 1:Bits
demap_out(t,(n-1)*Mod_type+1:n*Mod_type) = tempt(n,1:Mod_type)-48; 
end
end

%------------------------统计误码率-----------------------------------------%
% pqam_length = Bits*Mod_type;
error_ratio = 0;
error_num = 0;
sig_all_num = pqam_length*Tx_num;

error_matrix = zeros(Tx_num-1,pqam_length);
for t = 1:Tx_num-1 
for n = 1:pqam_length 
if demap_out(t,n)~=sig_code(t,n)
error_num = error_num+1;
error_matrix(t,n) = 1;
end
end
end
error_ratio = error_num/sig_all_num;
e_record(iterative_length) = error_ratio;
end % snr_db_step =snr_min:snr_max 

xanxis = snr_min:stepsize:snr_max;
if Mod_type == 4
semilogy(xanxis,e_record,'r*-'); 
legend('16qam T4R4 系统');
else Mod_type == 6
if Max_bit_num == 8
semilogy(xanxis,e_record,'ro-'); 
elseif Max_bit_num == 9
semilogy(xanxis,e_record,'g*-'); 
elseif Max_bit_num == 16
semilogy(xanxis,e_record,'b--'); 
else 
semilogy(xanxis,e_record,'m>-'); 
end
legend('64qam T4R4 系统');
end
grid on;
hold on;
add_flow_num
mult_flow_num