multi_awgn_vita_encode.m

来自「短波信道抗多音干扰的性能分析及其仿真」· M 代码 · 共 265 行

%function pb=multi_awgn_vita(Eb_to_Nj_in_dB,Eb_to_No_in_dB,BPH,number_of_states,Q)
%VITERBI      This procedure simulates the Viterbi sequnce decoding of the
%             differential frequency hopping system
%
%             Eb_to_Nj_in_dB is the signal-to-jamming ratio given in dB
%
%             Eb_to_No_in_dB is the signal-to-noise ratio given in dB
%
%             BPH is the number of bits transmitted by one hop
%
%             number_of_states is the number of states in the DFH
%             trellis,corresponding to the right L stages of the DFH encoding 
%             shift register 
%
%             Q is the number of jamming tones in the DFH bandwidth
%             这个程序是正确的,带(8,4)纠错码,但符号流总长度是2(N+L)(把补上的L个0符号也进行了编码,
%             有点小问题,但不影响结果),而multi_awgn_vita_84encoded.m是带(8,4)纠错码但符号流总长度是2N+L,这两个程序都对


%********系统参数********%
Eb_to_Nj_in_dB=15;
Eb_to_No_in_dB=13.35;
BPH=2;
number_of_states=16;
Q=1; % 干扰音的个数
%************************%




N=1000; % 每次符号流长度
times=10; % 重复做500次
fanout=2^BPH; % DFH的扇出系数
Eb_to_Nj=10^(Eb_to_Nj_in_dB/10); % 比值形式的Eb/Nj
Eb_to_No=10^(Eb_to_No_in_dB/10); % 比值形式的Eb/No
L=floor(log(number_of_states)/log(fanout)); % 编码移位寄存器的长度为L+1,最右边L级是其状态位,与网格图中的状态一一对应(注意并不是与跳频频点一一对应)

num_of_err=zeros(1,times);
% pb=zeros(1,times);
for rep=1:times

source=[randint(1,N,fanout),zeros(1,L)]; % 信息源:(注意不是10进制的,而是fanout进制的)随机符号流,最后补上L个0符号,使移位寄存器的状态清零

%***********************信源部分************************%

% 将信息符号流转化成二进制信息比特流,包括最后补上的L个0符号(dsource只是在最后计算误码率的时候用)
dsource=zeros(1,(N+L)*BPH); % 从N到N+L的改动 %*****
if(BPH~=1)
    for i=1:N+L
        dsource((i-1)*BPH+1:i*BPH)=deci2change(source(i),BPH,2);
    end
else
    dsource=source(1:N+L);%*****
end

%******************************************************%


% *******************差错控制编码部分(8,4)码**********************%
G=[1 0 0 0 1 0 1 1;
   0 1 0 0 1 1 1 0;
   0 0 1 0 1 1 0 1;
   0 0 0 1 0 1 1 1];
dsource_coded=encode(dsource,8,4,'linear',G);
source_coded=zeros(1,2*(N+L));
if (BPH~=1)
    for i=1:2*(N+L)
        register=dsource_coded((i-1)*BPH+1:i*BPH)';
        source_coded(i)=change2deci(register,2);
    end
else
    source_coded=dsource_coded(1:2*(N+L))';
end
% *****************************************************************%


% ******************* G 函数实现部分 ************************ %

% 先定义三个关键矩阵"nextstates" "output" "input"
nextstate=zeros(number_of_states,fanout); % nextstate矩阵:行代表网格图中的各状态(一一对应),列与输入移位寄存器的信息符号一一对应,
                                          % 矩阵中存储的内容是与当前状态和输入符号对应的下一状态号(即存储网格图的状态转移规则)  
output=zeros(number_of_states,fanout);    % output矩阵:行代表网格图中的各状态(一一对应),列与输入移位寄存器的信息符号一一对应,
                                          % 矩阵中存储的内容是与当前状态和输入符号对应的网格图分支转移输出(分支转移输出是跳频频率号)
input=zeros(number_of_states,number_of_states);
number_of_out=number_of_states*fanout;% 跳频频点数Nt
for i=0:number_of_states-1
    for j=0:fanout-1
        [next_state,out_put]=G_func1(i,j,L,fanout);
        nextstate(i+1,j+1)=next_state;
        output(i+1,j+1)=out_put;
        input(i+1,next_state+1)=j;
    end
end 
% ********************************************************* %


% ********************维特比译码部分**********************%

depth_of_trellis=length(source_coded);%*******************
Es=1;
Eb=Es/BPH;
% Ej0=(Eb*number_of_out*Q)/(Eb_to_Nj);% 每个多音干扰的能量Ej0
Ej0=(Es*number_of_out)/(BPH*Q*Eb_to_Nj); % 每跳时间内每个多音干扰的能量Ej0
sgma=sqrt(Eb/(2*Eb_to_No));% AWGN的均方根
thyta=2*pi*rand;% 干扰音与跳频信号的相对相位
demod_input=zeros(number_of_out,depth_of_trellis);
f=zeros(1,depth_of_trellis);
rc=zeros(1,number_of_out);
rs=zeros(1,number_of_out);
D=0; % D 记录网格图的当前状态,这里初始状态是0状态

% *******************信道和非相干解调部分:加多音干扰和噪声,然后非相干解调****************** %
for i=1:depth_of_trellis % i表示网格图的时间走势
    f(i)=output(D+1,source_coded(i)+1); % f(i)是i时刻的分支转移输出,即i时刻的跳频频率号 %************************
    J=randint(1,Q,number_of_out); % J 矩阵中存放Q个干扰音所在的频率号
    for j=0:number_of_out-1
        if (j==f(i))
            rc(j+1)=sqrt(Es)+sgma*randn;
            rs(j+1)=sgma*randn;
        else
            rc(j+1)=sgma*randn;
            rs(j+1)=sgma*randn;
        end
    end
    for k=1:Q
        for j=0:number_of_out-1
            if (j==J(k))
                rc(j+1)=rc(j+1)+sqrt(Ej0)*cos(thyta);
                rs(j+1)=rs(j+1)+sqrt(Ej0)*sin(thyta);
            end
        end
    end
    for j=0:number_of_out-1
        demod_input(j+1,i)=sqrt(rc(j+1)^2+rs(j+1)^2);
    end
    D=nextstate(D+1,source_coded(i)+1);   %*************************
end
            

% *******************信道和非相干解调部分:加多音干扰和噪声,然后非相干解调****************** %

% for i=1:depth_of_trellis % i表示网格图的时间走势
%     f(i)=output(D+1,source(i)+1); % f(i)是i时刻的分支转移输出,即i时刻的跳频频率号
%     J=randint(1,Q,number_of_out); % J 矩阵中存放Q个干扰音所在的频率号
%     for k=1:Q
%         for j=0:number_of_out-1
%             if (j==J(k)&j~=f(i)) % 频点上有干扰而无信号
%                 rc=sqrt(Ej0)*cos(thyta)+sgma*randn;
%                 rs=sqrt(Ej0)*sin(thyta)+sgma*randn;
%                 demod_input(j+1,i)=sqrt(rc^2+rs^2);
%             end
%             if (j==J(k)&j==f(i)) % 频点上既有干扰又有信号
%                 rc=sqrt(Es)+sqrt(Ej0)*cos(thyta)+sgma*randn;
%                 rs=sqrt(Ej0)*sin(thyta)+sgma*randn;
%                 demod_input(j+1,i)=sqrt(rc^2+rs^2);
%             end
%             if (j~=J(k)&j==f(i)) % 频点上有信号而无干扰
%                 rc=sqrt(Es)+sgma*randn;
%                 rs=sgma*randn;
%                 demod_input(j+1,i)=sqrt(rc^2+rs^2);
%             end
%             if (j~=J(k)&j~=f(i)) % 频点上既无信号又无干扰
%                 rc=sgma*randn;
%                 rs=sgma*randn;
%                 demod_input(j+1,i)=sqrt(rc^2+rs^2);
%             end
%         end
%     end
%     D=nextstate(D+1,source(i)+1);
% end
% ************************************************************************%



% sgma=sqrt(Es/(BPH*2*Eb_to_No));
% demod_input=zeros(number_of_out,depth_of_trellis);
% f=zeros(1,depth_of_trellis);
% D=0;
% for i=1:depth_of_trellis
%     f(i)=output(D+1,source(i)+1);
%     for j=0:number_of_out-1
%         if(j~=f(i))
%            rc=sgma*randn;
%            rs=sgma*randn;
%        else
%            rc=sqrt(E)+sgma*randn;
%            rs=sgma*randn;
%        end
%        demod_input(j+1,i)=sqrt(rc^2+rs^2);
%    end
%     D=nextstate(D+1,source(i)+1);
% end
% demod_input=demod_input/sgma^2;

state_metric=zeros(number_of_states,2);
survivor_state=zeros(number_of_states,depth_of_trellis+1);
for i=1:depth_of_trellis-L
    flag=zeros(1,number_of_states);
    if i<=L+1
        step=2^((L+1-i)*BPH);
    else
        step=1;
    end
    for j=0:step:number_of_states-1
        for m=0:fanout-1
            branch_metric=demod_input(output(j+1,m+1)+1,i);
            if((state_metric(nextstate(j+1,m+1)+1,2)<state_metric(j+1,1)...
                    +branch_metric)|flag(nextstate(j+1,m+1)+1)==0)
                state_metric(nextstate(j+1,m+1)+1,2)=state_metric(j+1,1)+branch_metric;
                survivor_state(nextstate(j+1,m+1)+1,i+1)=j;
                flag(nextstate(j+1,m+1)+1)=1;
            end
        end
    end
    state_metric=state_metric(:,2:-1:1);
end
for i=depth_of_trellis-L+1:depth_of_trellis
    flag=zeros(1,number_of_states);
    last_stop=number_of_states/(2^((i-depth_of_trellis+L-1)*BPH));
    for j=0:last_stop-1
        branch_metric=demod_input(output(j+1,m+1)+1,i);
        if((state_metric(nextstate(j+1,1)+1,2)<state_metric(j+1,1)...
            +branch_metric)|flag(nextstate(j+1,1)+1)==0)
            state_metric(nextstate(j+1,1)+1,2)=state_metric(j+1,1)+branch_metric;
            survivor_state(nextstate(j+1,1)+1,i+1)=j;
            flag(nextstate(j+1,1)+1)=1;
        end
    end
    state_metric=state_metric(:,2:-1:1);
end
state_sequence=zeros(1,depth_of_trellis+1);
for i=1:depth_of_trellis
    state_sequence(1,depth_of_trellis-i+1)=survivor_state((state_sequence(1,depth_of_trellis+2-i)...
        +1),depth_of_trellis-i+2);
end
decoder_output=zeros(1,BPH*(depth_of_trellis-L));% length(decoder_output)=BPH*(2N+L)
for i=1:depth_of_trellis-L
    dec_output_deci=input(state_sequence(1,i)+1,state_sequence(1,i+1)+1);
    if(BPH~=1)
        dec_output_bin=deci2change(dec_output_deci,BPH,2);
        decoder_output((i-1)*BPH+1:i*BPH)=dec_output_bin;
    else
        decoder_output(1,i)=dec_output_deci;
    end
end
% ************************************************************************%

% ***********(8,4)译码部分***********%

deco_input=zeros(1,BPH*2*(N+L));
deco_input(1:BPH*(2*N+L))=decoder_output(1:BPH*(2*N+L));
deco_output=decode(deco_input,8,4,'linear',G)';% (8,4)译码器的译码输出(长为BPH*(N+L)个比特,列矢量)

% ***********************************%


for i=1:(N+L)*BPH
    if(dsource(i)~=deco_output(i))
       num_of_err(rep)=num_of_err(rep)+1;
   end
end

end % 与最外层"多少遍" for循环对应的end

Pb=sum(num_of_err)/(N*times*BPH) % N 是一遍的符号流长度,总共进行times遍,共N*times个符号