I have made a blind DFE Equalization, I mean decision directed . But I am not sure how to make an implementation based on reference signal known by receiver and emitter. In the back forward filter adaptation how do I take this into consideration?

My second equation is to know if the updating rule for the RLS is the rigth one ?

Here is my rls tracking DFE matlab code


    close all; clc;
    MQAM = 2; 
    N = 1e2;
    L = 3;  
    LFF = 8;
    LFB = 8;
    target = 1e-6;
    error_min = 30;
    trans_min = 1e6;
    trans_max = error_min/target; 
    endSNR = 16;
    stepSNR = 2; 
    h = [1 0.5*exp(1i*pi/6)  0.1*exp(-1i*pi/8)]';
    eq = comm.DecisionFeedbackEqualizer('Algorithm', 'RLS', ...
               "AdaptAfterTraining",false, 'NumFeedbackTaps', LFB, ...
               'NumForwardTaps', LFF); eq.ReferenceTap = 1; 
    BER_mtlb = 0;
    handle = waitbar(0, 'Please wait...');

    p=LFF; lamda=0.98; sigma=1; P1=(sigma^-1)*eye(LFF);


    while SNR(iSNR)<= endSNR            
         error_num=0;trans_num=0;  error_mtlb = 0; 
         while  (error_num <= error_min) && (trans_num <= trans_min) 
             MemFF = zeros(LFF,1); MemBW = MemFF; hFF = zeros(LFF,1);
             hFB=hFF; hFF(ceil((LFF-1)/2)) = 1;

             s = randi([0 1],N,1);
             smod = qammod(s,MQAM,'gray','InputType','bit'); 
             xin = awgn(filter(h, 1, smod), SNR(iSNR), 'measured');

             out = zeros(N,1); dec = zeros(size(s)); sdec = zeros(size(s));
             smodCplx = complex(smod);
             [y, err, weigths] = eq(xin, smodCplx);
             rxx = qamdemod(y, MQAM, 'gray', 'OutputType', 'bit');
             error_mtlb = error_mtlb + sum( rxx ~= s);
             %- RLS DFE Equalization loop block 
             for n = 1: length(xin)
                 MemFF = [xin(n); MemFF(1:LFF-1)];
                 out(n) = transpose(hFF)*MemFF + transpose(hFB)*MemBW; 
                 sdec(n) = qamdemod(out(n),MQAM,'gray','OutputType','bit');
                 dec(n) = qammod(sdec(n),MQAM,'gray','InputType','bit');

                 alpha(n) = dec(n) - out(n);% error of RLS

                 g1(:,n)=P1*MemFF*((lamda + MemFF'*P1*MemFF).^-1); % Gain 
                 P1=(lamda^-1)*P1 - g1(:,n)*MemFF'*(lamda^-1)*P1; 

                 g2(:,n)=P2*MemBW*((lamda + MemBW'*P2*MemBW).^-1); % Gain 
                 P2=(lamda^-1)*P2 - g2(:,n)*MemBW'*(lamda^-1)*P2; 

                 hFF = hFF  + alpha(n)*g1(:,n);
                 hFB = hFB + alpha(n)*g2(:,n);
                 MemBW = [dec(n); MemBW(1:LFB-1)];


             M = min(length(s), length(sdec));
             Ryx = xcorr(1-2*sdec(1:M),1-2*s(1:M),'unbiased');
             [valMax,Delay] = max(abs(Ryx(M:M+99)));
             Delay = Delay-1;

             if (Ryx(M+Delay) < 0) 
                 sdec = qamdemod(-out,MQAM,'gray','OutputType','bit');
             sdec_synchronized = sdec(1+Delay:end);
             s_synchronized = s(1:length(sdec_synchronized));

             error_num = sum(s_synchronized~= sdec_synchronized) + error_num;
             trans_num = trans_num  + length(sdec_synchronized)  ;
         end % end this number of transmitted symbols

         BER(iSNR) = error_num/trans_num;
         BER_mtlb(iSNR) = error_mtlb/trans_num;
         iSNR = iSNR+1;
        SNR(iSNR) = SNR(iSNR-1) + stepSNR;
    SNR=SNR (1:length(BER)); berTheory =
    berawgn(SNR/log2(MQAM),'psk',2,'nondiff');  SNR =
    SNR(1:min(length(BER), length(BER_mtlb))); h = figure;
    semilogy(SNR,BER, 'b--'); hold on; semilogy(SNR, BER_mtlb, 'g--'); hold on;
    semilogy(SNR, berTheory, 'kx-'); legend('Simulation DFE', 'Theory');
    xh=xlabel('E_b/N_0 (dB)'); %yh = ylabel('Probability of bit error');
    xlabel('SNR (dB)'); ylabel('BER'); grid on;
    XMIN= 0; XMAX = 30; YMIN= 1e-7; YMAX= 1; axis([XMIN XMAX YMIN YMAX])

1 Answer 1


I can answer for adaptive filter containing feedback path alone as I have implemented it recently (both Blind DFE and with Reference Symbols), but it should work for DFE containing feed-forward path as well. In Blind DFE while computing the error, $e[n] = x[n] - \hat{x}[n]$, where $x[n]$ is the equalizer output, $\hat{x}[n]$ is the corresponding Hard Decision. But if you have reference symbol $r[n]$, you need not compare with hard decision output and $e[n] = x[n] - r[n]$.

If the reference symbols are placed in the beginning of data, then the filter adapts more reliably (delay and tap values) in the beginning itself, you can then use your Blind DFE for the remaining data part.

The example I have used comes from 802.11ad Single Carrier data packet where for each frame containing 512 symbols, the first 64 are known reference symbols and the rest 448 are random data symbols (BPSK/QPSK/16QAM). So for the first 64 symbols, I skipped the hard decision slicer and directly compared adaptive filter output with reference symbols. For the remaining 448 symbols, I used Blind DFE.

  • $\begingroup$ Here is my matlab implementation of a blind DFE with rls tracking but it does not fit with matlab implementation plus I am having hard time to make it with reference signals $\endgroup$
    – user47976
    May 1, 2020 at 15:38

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.