Conventional_OFDM.m

clc;
clear all;
%%
N = 64; % # of SCs
Q = 2;
SE = log2(Q);

SNRdB = 25;
SNR = 10.^(SNRdB/10);
N0 = 1./SNR; %Noise variance
sigma = sqrt(N0/2);

nFram = 50000; %Number of transmitted OFDM frame (increase this to get more accurate results in high SNR region)

ss = qammod(0:Q-1, Q, UnitAveragePower = true);
K = 4; % Number of rotations
% for k = 1:K
%     SS{k} = ss * exp(1j*k*pi/K); % Rotation
% end
SS{1} = ss;
%%% Channel Delay Profile
P = 5;
EYE_MAT = (eye(N));
PI_mat = ([EYE_MAT(:, 2:end) EYE_MAT(:, 1)]); %Cyclic shift matrix for delay paths

Fn = dftmtx(N);    %% Normalized N-point FFT matrix
Fn = Fn./norm(Fn); %% Normalized N-point FFT matrix

%%
totalError = zeros(nFram,1);
parfor i = 1:nFram

    %%%Channel
    hAB = sqrt(1/P).*(sqrt(1/2) * (randn(1,P)+1i*randn(1,P)));%channel coefs for the channel between Alice and Bob
    sigmae2 = 1e-3; %Ch. error variance
    chErr = sqrt(sigmae2/2) * (randn(1,P)+1i*randn(1,P));%Error coefficients
    hABe = hAB + chErr;% Ch. coefs with errors
    hAE = sqrt(1/P).*(sqrt(1/2) * (randn(1,P)+1i*randn(1,P)));%channel coefs for the channel between Alice and Eve

    Hab=zeros(N);
    Hae=zeros(N);
    HabE=zeros(N);
    for j = 1:P
        Hab = Hab + hAB(j)*(PI_mat^(j-1));
        HabE = HabE + hABe(j)*(PI_mat^(j-1));
        Hae = Hae + hAE(j)*(PI_mat^(j-1));
    end
    Hf_AB = Fn*Hab*Fn'; %Frequency domain channel response (will be used in equalizing)
    phaseABf = angle(sum(diag(Hf_AB)));
    Hf_ABe = Fn*HabE*Fn'; %Frequency domain channel response (will be used in equalizing)
    phaseABef = angle(sum(diag(Hf_ABe)));
    Hf_AE = Fn*Hae*Fn'; %Frequency domain channel response (will be used in equalizing)
    phaseAEf = angle(sum(diag(Hf_AE)));

    % phaseAB = angle(sum(hAB));
    % phaseABe = angle(sum(hAB));
    % phaseAE = angle(sum(hAE));
    % phases = linspace(-pi, pi, K);
    % 
    % [~, idxAB] = min(abs(phases - phaseABf));
    % [~, idxABe] = min(abs(phases - phaseABef));
    % [~, idxAE] = min(abs(phases - phaseAEf));
    % 
    % ssAB = exp(1j*phaseAB)*SS{idxAB};
    % ssABe = exp(1j*phaseABe)*SS{idxABe};
    % ssAE = exp(1j*phaseAE)*SS{idxAE};

    % ssAB  = exp(1j*phaseAB)*SS{1};
    ssAB  = SS{1};
    ssABe = SS{1};
    % ssAE  = SS{1};
    % ssAE  = exp(1j*phaseAE)*SS{1};

    %%%Channel

    %%% Transmitter
    nbits = SE*N; %Number of random bits
    bits = reshape(randi([0 1],nbits,1),N,SE); % Randomly generated bits
    xDec = bi2de(bits,'left-msb')+1; %Decimal equivalents of bits
    x = ssAB(xDec).'; %Corresponding QAM symbols
    s = Fn'*x;
    %%% Transmitter

    %%%Receiver
    %Bob
    w_AB = sigma*(randn(size(s)) + 1i*randn(size(s))); %Generating AWGN noise
    yF_AB = Hf_AB*x + Fn*w_AB; %effective domain
    Hf_AB = diag(Hf_AB);
    % yTilda_AB = yF_AB./Hf_AB; %Equalizer
    
    %Bob with errorneus channel
    Hf_ABe = diag(Hf_ABe);
    % yTilda_ABe = yF_AB./Hf_ABe; %Equalizer
    % yTilda_ABe = reshape(yTilda_ABe,G,n);

    %Eve
    % w_AE = sigma*(randn(size(s)) + 1i*randn(size(s))); %Generating AWGN noise
    % yF_AE = Hf_AE*x + Fn*w_AE; %effective domain
    % Hf_AE = diag(Hf_AE);
    % yTilda_AE = yF_AE./Hf_AE; %Equalizer

    detectedInt_AB  = zeros(N,1);
    detectedInt_ABe = zeros(N,1);
    % detectedInt_AE  = zeros(N,1);
    for k = 1:1:length(yF_AB) %Bit detector
        metric_AB  = zeros(1,Q);
        metric_ABe = zeros(1,Q);
        % metric_AE  = zeros(1,Q);
        for j = 1:Q
            metric_AB(j)  = norm(yF_AB(k)-Hf_AB(k).*ssAB(j)).^2;
            metric_ABe(j) = norm(yF_AB(k)-Hf_ABe(k).*ssABe(j)).^2;
            % metric_AE(j)  = norm(yF_AE(k)-Hf_AE(k).*ssAE(j)).^2;
        end
        [~, minInd_AB] = min(metric_AB);
        detectedInt_AB(k) = minInd_AB-1;

        [~, minInd_ABe] = min(metric_ABe);
        detectedInt_ABe(k) = minInd_ABe-1;

        % [~, minInd_AE] = min(metric_AE);
        % detectedInt_AE(k) = minInd_AE-1;
    end
    decodedBits_AB = int2bit(detectedInt_AB.',SE).';
    decodedBits_ABe = int2bit(detectedInt_ABe.',SE).';
    % decodedBits_AE = int2bit(detectedInt_AE.',SE).';
    %%%Receiver

    error_AB = xor(bits,decodedBits_AB);
    totalError_AB(i) = sum(error_AB(:));
    BER_AB(i) = totalError_AB(i)/numel(bits);

    error_ABe = xor(bits,decodedBits_ABe);
    totalError_ABe(i) = sum(error_ABe(:));
    BER_ABe(i) = totalError_ABe(i)/numel(bits);

    % error_AE = xor(bits,decodedBits_AE);
    % totalError_AE(i) = sum(error_AE(:));
    % BER_AE(i) = totalError_AE(i)/numel(bits);
end

ERROR_AB = sum(totalError_AB)
AvgBER_AB = mean(BER_AB)

ERROR_ABe = sum(totalError_ABe);
AvgBER_ABe = mean(BER_ABe)

% ERROR_AE = sum(totalError_AE);
% AvgBER_AE = mean(BER_AE)
%%
BER_ORJ = [];
BER_PRP = [];
BER_PER = [];
BER_EVE = [];