fix_1_soft_1664qam44.asv

stbc在2发2收

                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_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:Ofdm_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:Ofdm_bits
            demap_out(t,(n-1)*Mod_type+1:n*Mod_type) = tempt(n,1:Mod_type)-48;     
        end
    end
    
    %------------------------统计误码率-----------------------------------------%
    % pqam_length = Ofdm_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