Is DFE equalizer always blind or can we use reference signal?

Question

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

`

    clearvars;
    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; 
    BER=0;
    SNR=0;
    iSNR=1;
    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);

    P2=(sigma^-1)*eye(LFB);

    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)];

             end

             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');
             end
             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;
         waitbar(log10(BER(iSNR))/log10(target),handle);
         iSNR = iSNR+1;
        SNR(iSNR) = SNR(iSNR-1) + stepSNR;
 end
    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])

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.