stbc_decode24.m

stbc在2发2收

% demap_int = zeros(Tx_num,Ofdm_bits);
% stbc_code 为信源发送信号
% snr_db_step 当前信噪比
% demap_int 译码得到的信号表的索引号

function [decode_out,demap_int] = stbc_decode(stbc_code,snr_db_step);
global table16 table64 Mod_type Ofdm_bits Time_length Tx_num Rx_num
global Max_quantity_bits Max_value Min_value Max_add_value
mult_flow_num = 0;
add_flow_num = 0;
    rec_code = zeros(Time_length,Rx_num,Ofdm_bits);
    channel_mul_noice = zeros(Tx_num,Rx_num,Ofdm_bits);
    ch_mul_noice = sqrt(0.5)*(randn(Tx_num,Rx_num,Ofdm_bits)+j*randn(Tx_num,Rx_num,Ofdm_bits));
    for n = 1:Time_length 
        for m = 1:Ofdm_bits
            rec_code(n,:,m) = stbc_code(n,1:Tx_num,m)*ch_mul_noice(1:Tx_num,1:Rx_num,m);
        end
    end
    
    %---------------------信号功率统计,加高斯白噪声----------------------------%
    sig_pante_pow = 0;
    for n = 1:Rx_num
        Agwn = sqrt(10^(-snr_db_step/10)/2)*(randn(Time_length,1,Ofdm_bits)+j*randn(Time_length,1,Ofdm_bits));
        rec_code(:,n,:) = rec_code(:,n,:) + Agwn;      
    end
    ch_scale = sqrt(Tx_num);
    rec_code = rec_code*ch_scale;
    
    %%%%%%%%%%%%%%%%%%%%%%%%%% 定点仿真 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    
    %------------------------接收信号并进行stbc译码----------------------------%
    max_rec_code = max(max(max(max(real(rec_code),imag(rec_code)))));
    max_rec_code = fix(max_rec_code/fix(max_rec_code+0.5)*Max_value)/Max_value*fix(max_rec_code+0.5);
    rec_code = rec_code/max_rec_code;   % 信号归一化
    rec_code = fix(rec_code*Max_value);
    max_ch_noice = max(max(max(max(real(ch_mul_noice),imag(ch_mul_noice)))));
    max_ch_noice = fix(max_ch_noice/fix(max_ch_noice+0.5)*Max_value)/Max_value*fix(max_ch_noice+0.5);
    ch_mul_noice = ch_mul_noice/max_ch_noice;
    ch_mul_noice = fix(ch_mul_noice*Max_value);
    
    rec_code_r = real(rec_code);
    rec_code_i = imag(rec_code);
    ch_mul_noice_r = real(ch_mul_noice);
    ch_mul_noice_i = imag(ch_mul_noice);
    demap_int = zeros(Tx_num,Ofdm_bits);
    
    compare_tempt = zeros(Time_length,2); 
    result_index = zeros(1,Time_length);
    if Mod_type == 4
        star_index_length = 16;
    end
    if Mod_type == 6
        star_index_length = 64;
    end
    for n = 1:Ofdm_bits       
        decode_tempt_r = zeros(1,2);      % Time_length = 2
        decode_tempt_i = zeros(1,2);
        m = reshape(ch_mul_noice(:,:,n),1,8);              % 8 = Tx_num*Rx_num=2*4
        tempt_scale = 1;
        %ch_sum = norm(m)^2*(max_ch_noice*max_ch_noice);
        for r =  1:Rx_num        
            %decode_tempt(1,1) = decode_tempt(1,1) + rec_code(1,r,n)*conj(ch_mul_noice(1,r,n))+ conj(rec_code(2,r,n))*ch_mul_noice(2,r,n);            
            mult_tempt(1,1) = rec_code_r(1,r,n)*ch_mul_noice_r(1,r,n);
            mult_tempt(1,2) = rec_code_i(1,r,n)*ch_mul_noice_i(1,r,n);
            mult_tempt(1,3) = rec_code_r(2,r,n)*ch_mul_noice_r(2,r,n);
            mult_tempt(1,4) = rec_code_i(2,r,n)*ch_mul_noice_i(2,r,n);
            
            for nnn = 1:4
                if mult_tempt(1,nnn) >= Max_add_value
                    mult_temp(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 = (mult_tempt(1,1) + mult_tempt(1,2)+mult_tempt(1,3) +mult_tempt(1,4))/tempt_scale;              
            decode_tempt_r(1,1) = decode_tempt_r(1,1) + sum_tempt;
            
            if decode_tempt_r(1,1) >= Max_add_value
                decode_tempt_r(1,1) = Max_add_value-1;
            elseif decode_tempt_r(1,1) <-Max_add_value
                decode_tempt_r(1,1) = -Max_add_value;
            end
            
            
            mult_tempt(1,1) = -rec_code_r(1,r,n)*ch_mul_noice_i(1,r,n);
            mult_tempt(1,2) = rec_code_i(1,r,n)*ch_mul_noice_r(1,r,n);
            mult_tempt(1,3) = rec_code_r(2,r,n)*ch_mul_noice_i(2,r,n);
            mult_tempt(1,4) = -rec_code_i(2,r,n)*ch_mul_noice_r(2,r,n);
            
            for nnn = 1:4
                if mult_tempt(1,nnn) >= Max_add_value
                    mult_temp(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 = (mult_tempt(1,1)+mult_tempt(1,2)+mult_tempt(1,3)+mult_tempt(1,4))/tempt_scale;         
            decode_tempt_i(1,1) = decode_tempt_i(1,1)+sum_tempt;               
            
            if decode_tempt_i(1,1) >= Max_add_value
                decode_tempt_i(1,1) = Max_add_value-1;
            elseif decode_tempt_i(1,1) <-Max_add_value
                decode_tempt_i(1,1) = -Max_add_value;
            end
            %decode_tempt(1,2) = decode_tempt(1,2) + rec_code(1,r,n)*conj(ch_mul_noice(2,r,n))- conj(rec_code(2,r,n))*ch_mul_noice(1,r,n); 
            mult_tempt(1,1) = rec_code_r(1,r,n)*ch_mul_noice_r(2,r,n);
            mult_tempt(1,2) = rec_code_i(1,r,n)*ch_mul_noice_i(2,r,n);
            mult_tempt(1,3) = -rec_code_r(2,r,n)*ch_mul_noice_r(1,r,n);
            mult_tempt(1,4) = -rec_code_i(2,r,n)*ch_mul_noice_i(1,r,n);
            
            for nnn = 1:4
                if mult_tempt(1,nnn) >= Max_add_value
                    mult_temp(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 = (mult_tempt(1,1)+mult_tempt(1,2)+mult_tempt(1,3)+mult_tempt(1,4))/tempt_scale; 
            decode_tempt_r(1,2) = decode_tempt_r(1,2)+sum_tempt;
            
            if decode_tempt_i(1,2) >= Max_add_value
                decode_tempt_i(1,2) = Max_add_value-1;
                add_flow_num = add_flow_num+1;
            elseif decode_tempt_i(1,2) <-Max_add_value
                decode_tempt_i(1,2) = -Max_add_value;
                add_flow_num = add_flow_num+1;
            end
            
            mult_tempt(1,1) = -rec_code_r(1,r,n)*ch_mul_noice_i(2,r,n);
            mult_tempt(1,2) = rec_code_i(1,r,n)*ch_mul_noice_r(2,r,n);
            mult_tempt(1,3) = -rec_code_r(2,r,n)*ch_mul_noice_i(1,r,n);
            mult_tempt(1,4) = rec_code_i(2,r,n)*ch_mul_noice_r(1,r,n);
            
            for nnn = 1:4
                if mult_tempt(1,nnn) >= Max_add_value
                    mult_temp(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 = (mult_tempt(1,1)+mult_tempt(1,2)+mult_tempt(1,3) +mult_tempt(1,4))/tempt_scale; 
            decode_tempt_i(1,2) = decode_tempt_i(1,2)+ sum_tempt;
            
            if decode_tempt_i(1,2) >= Max_add_value
                decode_tempt_i(1,2) = Max_add_value-1;
                add_flow_num = add_flow_num+1;
            elseif decode_tempt_i(1,2) <-Max_add_value
                decode_tempt_i(1,2) = -Max_add_value;
                add_flow_num = add_flow_num+1;
            end
            if r == Rx_num-1
                tempt_scale = 2;
                decode_tempt_r(1,1) = decode_tempt_r(1,1)/2;
                decode_tempt_i(1,1) = decode_tempt_i(1,1)/2;
                decode_tempt_r(1,2) = decode_tempt_r(1,2)/2;
                decode_tempt_i(1,2) = decode_tempt_i(1,2)/2;
            end 
        end%r =  1:Rx_num 
            
            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
            bit = 6;
            scale = 2^bit;
            %Max_value2 = 2^(2*Max_quantity_bits-2);
            Max_value2 = 2^(Max_quantity_bits+bit+1);
            decode_tempt_r(1,1) = fix(decode_tempt_r(1,1)*max_rec_code/Max_value*scale);
            decode_tempt_r(1,2) = fix(decode_tempt_r(1,2)*max_rec_code/Max_value*scale);
            decode_tempt_i(1,1) = fix(decode_tempt_i(1,1)*max_rec_code/Max_value*scale);
            decode_tempt_i(1,2) = fix(decode_tempt_i(1,2)*max_rec_code/Max_value*scale);
            
            if abs(decode_tempt_r(1,1))>Max_value2|abs(decode_tempt_i(1,1))>Max_value2|...
                    abs(decode_tempt_r(1,2))>Max_value2|abs(decode_tempt_i(1,2))>Max_value2
                add_flow_num = add_flow_num+1;
            end
            if decode_tempt_r(1,1) >=Max_value2
                decode_tempt_r(1,1) = Max_value2-1;
            elseif decode_tempt_r(1,1)<-Max_value2
                decode_tempt_r(1,1) = -Max_value2;
            end
            if decode_tempt_i(1,1) >=Max_value2
                decode_tempt_i(1,1) = Max_value2-1;
            elseif decode_tempt_i(1,1)<-Max_value2
                decode_tempt_i(1,1) = -Max_value2;
            end
            if decode_tempt_r(1,2) >=Max_value2
                decode_tempt_r(1,2) = Max_value2-1;
            elseif decode_tempt_r(1,2)<-Max_value2
                decode_tempt_r(1,2) = -Max_value2;
            end
            if decode_tempt_i(1,2) >=Max_value2
                decode_tempt_i(1,2) = Max_value2-1;
            elseif decode_tempt_i(1,2)<-Max_value2
                decode_tempt_i(1,2) = -Max_value2;
            end
            ch_sum = 0;       
            for n1 = 1:Tx_num*Rx_num
                ch_sum = ch_sum + real(m(n1))^2+imag(m(n1))^2;
            end
            
            % 根据下面两式子的比较，可见，ch_sum的精确对判决的重要作用
            % 所以tempt_scale取得过小会有摆尾现象，太大又会溢出；
            % 16qam 和 64qam的tempt_scale取值不同，才可保证两个qam都可以得到好的性能
            bit = 6;
            tempt_scale = 2^bit;         
            ch_sum = fix(ch_sum/Max_value^2*max_ch_noice*tempt_scale);
            %ch_sum = ch_sum/Max_value^2*max_ch_noice*max_ch_noice;
            %Max_value3 = 2^(2*Max_quantity_bits-6);
            Max_value3 = 2^(Max_quantity_bits+bit-2);
            if ch_sum>=Max_value3
                ch_sum = Max_value3-1;
                add_flow_num = add_flow_num+1;
            end
            
            % decode_tempt 就是译码输出的软信息（用8bits量化）
            decode_tempt_r(1,1) = fix((decode_tempt_r(1,1)/ch_sum)*tempt_scale/scale)*2;
            decode_tempt_i(1,1) = fix((decode_tempt_i(1,1)/ch_sum)*tempt_scale/scale)*2;
            decode_tempt_r(1,2) = fix((decode_tempt_r(1,2)/ch_sum)*tempt_scale/scale)*2;
            decode_tempt_i(1,2) = fix((decode_tempt_i(1,2)/ch_sum)*tempt_scale/scale)*2;
            if Mod_type == 6
                decode_tempt_r(1,1) = fix(decode_tempt_r(1,1)*127/138);
                decode_tempt_i(1,1) = fix(decode_tempt_i(1,1)*127/138);
                decode_tempt_r(1,2) = fix(decode_tempt_r(1,2)*127/138);
                decode_tempt_i(1,2) = fix(decode_tempt_i(1,2)*127/138);
            end
            
            if abs(decode_tempt_r(1,1))>Max_value|abs(decode_tempt_i(1,1))>Max_value|...
                    abs(decode_tempt_r(1,2))>Max_value|abs(decode_tempt_i(1,2))>Max_value
                add_flow_num = add_flow_num+1;
            end
            if decode_tempt_r(1,1) >=Max_value
                decode_tempt_r(1,1) = Max_value-1;
            elseif decode_tempt_r(1,1)<Min_value
                decode_tempt_r(1,1) = Min_value;
            end
            if decode_tempt_i(1,1) >=Max_value
                decode_tempt_i(1,1) = Max_value-1;
            elseif decode_tempt_i(1,1)<Min_value
                decode_tempt_i(1,1) = Min_value;
            end
            if decode_tempt_r(1,2) >=Max_value
                decode_tempt_r(1,2) = Max_value-1;
            elseif decode_tempt_r(1,2)<Min_value
                decode_tempt_r(1,2) = Min_value;
            end
            if decode_tempt_i(1,2) >=Max_value
                decode_tempt_i(1,2) = Max_value-1;
            elseif decode_tempt_i(1,2)<Min_value
                decode_tempt_i(1,2) = Min_value;
            end
            if Mod_type == 4
                star_index_length = 16;
                tempt_table = table16;
            elseif Mod_type == 6
                star_index_length = 64;
                tempt_table = table64;
            end
            decode_out(1,n) = decode_tempt_r(1,1)+j*decode_tempt_i(1,1);
            decode_out(2,n) = decode_tempt_r(1,2)+j*decode_tempt_i(1,2);
            for star_index = 1:star_index_length
                
                % 这里和L263
                % decode_tempt_r(1,1) = fix((decode_tempt_r(1,1)/ch_sum)/2)*tempt_scale;
                % 中 除以2，是因为在16qam中，7/sqrt(42)>1，所以为了让所有的星座点都<1,必须除以2；
                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;
                
                if star_index==1
                    compare_tempt(1,2) = compare_tempt(1,1);
                    compare_tempt(2,2) = compare_tempt(2,1); 
                    result_index(1) = star_index;
                    result_index(2) = 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
                end
            end % star_index = 1:16 or 1:64
            demap_int(1,n) = result_index(1)-1;
            demap_int(2,n) = result_index(2)-1;
            
        end  % n = 1:Ofdm_bits