stbc_decode24.asv

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;

%%%%%%%%%%%%%%%%%%%%%%%%%% 定点仿真 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%------------------------接收信号并进行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取得过小会有摆尾现象，太大又会溢出；
    bit = 6;
    tempt_scale = 2^bit;         
    ch_sum = fix(ch_sum/Max_value^2*max_ch_noice*tempt_scale);
    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       
        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