Wi-Fi 8 Downlink Packet Error Rate Simulation Using Unequal Modulation

useBeamforming = true;

NumTxAnts = 4;                                      % Number of transmit antennas
NumSTS = 2;                                         % Number of space-time streams
NumRxAnts = 2;                                      % Number of receive antennas

if useBeamforming
    spatialMapping = 'Custom';                      % Custom for beamforming
    Ng = 16;                                        % Subcarrier grouping for beamforming. Ng must be 1 (no grouping), 4, or 16.
else
    spatialMapping = 'Fourier'; %#ok<UNRCH>         % Fourier mapping for non-beamforming
end

chanBW = 'CBW20';                                   % Channel bandwidth
cfgUHRBase = uhrMUConfig(chanBW);
cfgUHRBase.NumTransmitAntennas = NumTxAnts;         % Number of transmit antennas
cfgUHRBase.GuardInterval = 3.2;                     % Guard interval duration
cfgUHRBase.UHRLTFType = 4;                          % UHR-LTF compression mode
cfgUHRBase.User{1}.NumSpaceTimeStreams = NumSTS;    % Number of space-time streams
cfgUHRBase.User{1}.APEPLength = 1e4;                % Payload length in bytes
cfgUHRBase.User{1}.ChannelCoding = 'ldpc2x';        % 2xLDPC Channel coding
cfgUHRBase.RU{1}.SpatialMapping = spatialMapping;   % Spatial mapping

useUEQM = true;
if useUEQM
    % 1st SS - 4096 QAM
    % 2nd SS - 1024 QAM
    mcs = [13 11];
else
    mcs = 13; %#ok<UNRCH> 
end
cfgUHRBase.User{1}.MCS = mcs;                       % Modulation and coding scheme
disp(cfgUHRBase.User{1})

if useBeamforming
    cfgNDP = cfgUHRBase;
    cfgNDP.User{1}.APEPLength = 0;                     % NDP has no data
    cfgNDP.User{1}.NumSpaceTimeStreams = NumTxAnts;    % For feedback matrix calculation
    cfgNDP.User{1}.MCS = 0;                            % Set MCS to 0 to skip UEQM validation
    cfgNDP.RU{1}.SpatialMapping = 'Direct';            % Each TxAnt carries an STS

    if Ng>1
        % Subcarrier grouping
        indicesGrouping = helperCompressedBeamformingSubcarrierIndices(cfgNDP,Ng);
    end

    % Transmit null data packet and add trailing zeros to allow for channel delay
    ndpTxWaveform = [uhrWaveformGenerator([],cfgNDP); zeros(50,cfgNDP.NumTransmitAntennas)];

    indSound = uhrFieldIndices(cfgNDP);
end

% Create and configure the TGax channel
tgaxChannel = wlanTGaxChannel;
tgaxChannel.DelayProfile = 'Model-B';
tgaxChannel.NumTransmitAntennas = NumTxAnts;
tgaxChannel.NumReceiveAntennas = NumRxAnts;
tgaxChannel.TransmitReceiveDistance = 5; % Distance in meters for NLOS
tgaxChannel.ChannelBandwidth = chanBW;
tgaxChannel.LargeScaleFadingEffect = 'None';
tgaxChannel.NormalizeChannelOutputs = false;
fs = wlanSampleRate(chanBW);
tgaxChannel.SampleRate = fs;

if useBeamforming
    snr = 31:3:43;
else
    snr = 39:6:63; %#ok<UNRCH> 
end

if useUEQM
    snr = snr-3;     % Shift SNR values for UEQM scenarios
end

maxNumErrors = 10;   % The maximum number of packet errors at an SNR point
maxNumPackets = 100; % The maximum number of packets at an SNR point

numSNR = numel(snr); % Number of SNR points
packetErrorRate = zeros(1,numSNR);

% Get occupied subcarrier indices and OFDM parameters
ofdmInfo = uhrOFDMInfo('UHR-Data',cfgUHRBase);

% Indices to extract fields from the PPDU
ind = uhrFieldIndices(cfgUHRBase);

% PSDU length in bytes
psduLengthInBytes = psduLength(cfgUHRBase);

%parfor isnr = 1:numSNR % Use 'parfor' to speed up the simulation
for isnr = 1:numSNR
    % Set random substream index per iteration to ensure that each
    % iteration uses a repeatable set of random numbers
    stream = RandStream('combRecursive','Seed',99);
    stream.Substream = isnr;
    RandStream.setGlobalStream(stream);

    % Convert the SNR per active subcarrier to total SNR to account for
    % noise energy in null subcarriers
    snrValue = convertSNR(snr(isnr),"snrsc","snr",...
        FFTLength=ofdmInfo.FFTLength,...
        NumActiveSubcarriers=ofdmInfo.NumTones);

    % Create an instance of the UHR configuration object per SNR point
    % simulated. This enables you to use parfor.
    cfgUHR = cfgUHRBase;

    % Loop to simulate multiple packets
    numPacketErrors = 0;
    numPkt = 1; % Index of packet transmitted
    while numPacketErrors<=maxNumErrors && numPkt<=maxNumPackets
        % Pass through a TGax indoor fading channel
        reset(tgaxChannel); % Reset channel for different realization

        if useBeamforming
            % NDP transmission
            rx = tgaxChannel(ndpTxWaveform);

            % Pass the waveform through AWGN channel
            rx = awgn(rx,snrValue);

            % Calculate the steering matrix at the beamformee
            V = helperUserBeamformingFeedback(rx,cfgNDP,indSound,Ng);

            if isempty(V)
                % User feedback failed, packet error
                numPacketErrors = numPacketErrors+1;
                numPkt = numPkt+1;
                continue; % Go to next loop iteration
            end

            % Subcarrier interpolation
            if Ng>1
                steeringMat = interpolateSteeringMatrix(V,ofdmInfo.NumTones,indicesGrouping);
            else
                steeringMat = V; % No grouping
            end

            cfgUHR.RU{1}.SpatialMappingMatrix = steeringMat;
        end

        % Data packet transmission
        txPSDU = randi([0 1],psduLengthInBytes*8,1); % Generate random PSDU
        tx = uhrWaveformGenerator(txPSDU,cfgUHR);

        % Add trailing zeros to allow for channel delay
        txPad = [tx; zeros(50,cfgUHR.NumTransmitAntennas)];

        % Pass through a fading indoor TGax channel
        rx = tgaxChannel(txPad);

        % Pass the waveform through AWGN channel
        rx = awgn(rx,snrValue);

        % Packet detect and determine coarse packet offset
        coarsePktOffset = wlanPacketDetect(rx,chanBW);
        if isempty(coarsePktOffset) % If empty no L-STF detected; packet error
            numPacketErrors = numPacketErrors+1;
            numPkt = numPkt+1;
            continue; % Go to next loop iteration
        end

        % Extract L-STF and perform coarse frequency offset correction
        lstf = rx(coarsePktOffset+(ind.LSTF(1):ind.LSTF(2)),:);
        coarseFreqOff = wlanCoarseCFOEstimate(lstf,chanBW);
        rx = frequencyOffset(rx,fs,-coarseFreqOff);

        % Extract the non-HT fields and determine fine packet offset
        nonhtfields = rx(coarsePktOffset+(ind.LSTF(1):ind.LSIG(2)),:);
        finePktOffset = wlanSymbolTimingEstimate(nonhtfields,chanBW);

        % Determine final packet offset
        pktOffset = coarsePktOffset+finePktOffset;

        % Register a packet error if packet detected outside
        % the range of expected delays from the channel modeling
        if pktOffset>50
            numPacketErrors = numPacketErrors+1;
            numPkt = numPkt+1;
            continue; % Go to next loop iteration
        end

        % Extract L-LTF and perform fine frequency offset correction
        rxLLTF = rx(pktOffset+(ind.LLTF(1):ind.LLTF(2)),:);
        fineFreqOff = wlanFineCFOEstimate(rxLLTF,chanBW);
        rx = frequencyOffset(rx,fs,-fineFreqOff);

        % UHR-LTF demodulation and channel estimation
        rxUHRLTF = rx(pktOffset+(ind.UHRLTF(1):ind.UHRLTF(2)),:);
        uhrltfDemod = uhrDemodulate(rxUHRLTF,'UHR-LTF',cfgUHR);
        [chanEst,pilotEst] = uhrLTFChannelEstimate(uhrltfDemod,cfgUHR);

        % Data demodulate
        rxData = rx(pktOffset+(ind.UHRData(1):ind.UHRData(2)),:);
        demodSym = uhrDemodulate(rxData,'UHR-Data',cfgUHR);

        % Pilot phase tracking
        % Average single-stream pilot estimates over symbols (2nd dimension)
        pilotEstTrack = mean(pilotEst,2);
        demodSym = uhrTrackPilotError(demodSym,pilotEstTrack,cfgUHR,'UHR-Data');

        % Estimate noise power in UHR fields
        nVarEst = uhrDataNoiseEstimate(demodSym(ofdmInfo.PilotIndices,:,:),pilotEstTrack,cfgUHR);

        % Extract data subcarriers from demodulated symbols and channel estimate
        demodDataSym = demodSym(ofdmInfo.DataIndices,:,:);
        chanEstData = chanEst(ofdmInfo.DataIndices,:,:);

        % Equalization
        [eqDataSym,csi] = uhrEqualize(demodDataSym,chanEstData,nVarEst,cfgUHR,'UHR-Data');

        % Recover data
        rxPSDU = uhrDataBitRecover(eqDataSym,nVarEst,csi,cfgUHR);

        % Determine if any bits are in error, i.e. a packet error
        packetError = ~isequal(txPSDU,rxPSDU);
        numPacketErrors = numPacketErrors+packetError;
        numPkt = numPkt+1;
    end

    % Calculate packet error rate (PER) at SNR point
    packetErrorRate(:,isnr) = numPacketErrors/(numPkt-1);
    disp(['MCS ' num2str(cfgUHR.User{1}.MCS) ','...
        ' SNR ' num2str(snr(isnr)) ' dB'...
        ' completed after ' num2str(numPkt-1) ' packets,'...
        ' PER:' num2str(packetErrorRate(:,isnr))]);
end

markers = 'ox*sd^v><ph+ox*sd^v><ph+';
figure;
semilogy(snr,packetErrorRate.',['-' markers(1)]);
hold on;
grid on;
xlabel('SNR (dB)');
ylabel('PER');
if isscalar(mcs)
    dataStr = sprintf('MCS %d',mcs);
else
    mcsStr = cell(1,NumSTS);
    for iNumSTSs = 1:NumSTS
        mcsStr{iNumSTSs} = sprintf('%d ',mcs(iNumSTSs));
    end
    dataStr = strjoin(['MCS', mcsStr]);
end
legend(dataStr,'Location','NorthEastOutside');
title(['PER (UHR MU), ' num2str(cfgUHRBase.ChannelBandwidth) ', Model-B, ' num2str(NumTxAnts) '-by-' num2str(NumRxAnts)]);