MATLAB Examples

802.11ad Packet Error Rate Simulation for Single Carrier PHY

This example shows how to measure the packet error rate of an IEEE® 802.11ad™ DMG single carrier (SC) PHY AWGN link using an end-to-end simulation.



In this example an end-to-end simulation is used to determine the packet error rate for an 802.11ad SC [ 1 ] link with an AWGN channel at a selection of SNR points. At each SNR point multiple packets are transmitted through a noisy channel, synchronized, demodulated and the PSDUs recovered. Carrier frequency offset and a time delay are also modeled. The PSDUs are compared to those transmitted to determine the number of packet errors and hence the packet error rate. The processing for each packet is summarized in the following diagram.

This example also demonstrates how a parfor loop can be used instead of the for loop when simulating each SNR point to speed up a simulation. parfor, as part of the Parallel Computing Toolbox™, executes processing for each SNR in parallel to reduce the total simulation time.

Waveform Configuration

An 802.11ad DMG SC PHY transmission is simulated in this example. The DMG format configuration object contains the format specific configuration of the transmission. The object is created using the wlanDMGConfig function. The properties of the object contains the configuration of the transmitted packet. In this example the object is configured to generate a single carrier waveform of MCS "9". The MCS determines the PHY type used and in this example it must be a string within the range 1-12, or one of {9.1 12.1 12.2 12.3 12.4 12.5 12.6} to simulate the SC PHY.

% Create a format configuration object
cfgDMG = wlanDMGConfig;
mcs = "9"; % MCS specified as a string scalar or string vector
cfgDMG.PSDULength = 4096; % PSDULength in bytes

Simulation Parameters

For each SNR point (dB) in the cell snrRanges a number of packets are generated, passed through a channel and demodulated to determine the packet error rate. The SNR points to test are selected from snrRanges based on the MCS simulated.

snrRanges = {-2.5:0.5:0, ...  % MCS 1
             -0.5:0.5:2, ...  % MCS 2
             1:0.5:3.5, ...   % MCS 3
             2:0.5:4.5, ...   % MCS 4
             3:0.5:5.5, ...   % MCS 5
             3:0.5:5.5, ...   % MCS 6
             4:0.5:6.5, ...   % MCS 7
             5:0.5:7.5, ...   % MCS 8
             6:0.5:8.5, ...   % MCS 9
             7:0.5:9.5, ...   % MCS 9.1
             8.5:0.5:11, ...  % MCS 10
             10:0.5:12.5, ... % MCS 11
             11.5:0.5:14, ... % MCS 12
             12.5:0.5:15, ... % MCS 12.1
             13.5:0.5:16, ... % MCS 12.2
             14.5:0.5:17, ... % MCS 12.3
             16.5:0.5:19, ... % MCS 12.4
             17.5:0.5:20, ... % MCS 12.5
             19:0.5:21.5};    % MCS 12.6

The number of packets tested at each SNR point is controlled by two parameters:

  1. maxNumErrors is the maximum number of packet errors simulated at each SNR point. When the number of packet errors reaches this limit, the simulation at this SNR point is complete.
  2. maxNumPackets is the maximum number of packets simulated at each SNR point and limits the length of the simulation if the packet error limit is not reached.

The numbers chosen in this example will lead to a very short simulation. For meaningful results we recommend increasing the numbers.

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

Channel Impairment

The maximum tolerance for the transmitter center frequency must be within [-20, +20] ppm [ 1 ]. In this example, a clock accuracy of 20ppm is considered to derive the CFO. The transmitted signal is delayed by 500 samples.

delay = 500;              % Sample to delay the waveform
ppm = 20;                 % Clock accuracy to drive the CFO (ppm)
fc = 60e9;                % Carrier frequency (Hz)
freqOffset = ppm*1e-6*fc; % Carrier frequency offset (Hz)

Processing SNR Points

For each SNR point a number of packets are tested and the packet error rate calculated.

For each packet the following processing steps occur:

  1. A PSDU is created and encoded to create a single packet waveform.
  2. AWGN is added to the waveform. comm.AWGNChannel is configured to provide the correct SNR.
  3. The frequency offset impairment is added to each packet.
  4. The packet is detected.
  5. Carrier frequency offset is estimated and corrected.
  6. Fine timing synchronization is established. The CE field samples are provided for fine timing to allow for packet detection at the start of the STF.
  7. The STF and CE fields are extracted from the synchronized received waveform. The noise and channel estimation is performed on the recovered fields respectively.
  8. The data field, excluding the first guard interval is extracted and reshaped into blocks. The received symbols in the data field are equalized.
  9. The received symbols are tracked and corrected for phase errors caused by any residual carrier frequency offset.
  10. The data field is decoded to recover the PSDU bits.

A parfor loop can be used to parallelize processing of the SNR points, therefore for each SNR point an AWGN channel is created and configured with comm.AWGNChannel. To enable the use of parallel computing for increased speed comment out the for statement and uncomment the parfor statement below.

numSNR = numel(snrRanges{1}); % Number of SNR points
if ~isstring(mcs)
    error('MCS must be specified as a string scalar or string vector');
numMCS = numel(mcs);          % Number of MCS
packetErrorRate = zeros(numMCS,numSNR);
fs = wlanSampleRate(cfgDMG);
Ngi = 64; % Fixed GI length defined in the standard (
validMCS = string(sort([1:12 9.1 12.1:0.1:12.6]));

for imcs = 1:numMCS
    cfgDMG.MCS = mcs(imcs);
    if ~strcmp(phyType(cfgDMG),'SC')
        error('This example only supports DMG SC PHY simulation');
    ind = wlanFieldIndices(cfgDMG);
    snr = snrRanges{mcs(imcs)==validMCS}; % SNR points to simulate from MCS

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

        % Create an instance of the AWGN channel per SNR point simulated
        awgnChannel = comm.AWGNChannel;
        awgnChannel.NoiseMethod = 'Signal to noise ratio (SNR)';
        awgnChannel.SNR = snr(isnr);

        % Set simulation parameters
        numPacketErrors = 0;
        numPkt = 1; % Index of the transmitted packet
        while numPacketErrors<=maxNumErrors && numPkt<=maxNumPackets
            % Generate a packet waveform
            psdu = randi([0 1],cfgDMG.PSDULength*8,1);
            txWaveform = wlanWaveformGenerator(psdu,cfgDMG);

            % Add delay
            tx = [zeros(delay,1); txWaveform];

            % Add noise
            rx = awgnChannel(tx);

            % Add CFO
            rx = helperFrequencyOffset(rx,fs,freqOffset);

            % Packet detection
            threshold = 0.03; % Good for low SNRs
            pktStartOffset = dmgPacketDetect(rx,0,threshold);
            if isempty(pktStartOffset) % If empty no STF detected; packet error
                numPacketErrors = numPacketErrors+1;
                numPkt = numPkt+1;
                continue; % Go to next loop iteration

            % Frequency offset estimation and correction
            stf = rx(pktStartOffset+(ind.DMGSTF(1):ind.DMGSTF(2)));
            fOffsetEst = dmgCFOEstimate(stf);
            rx = helperFrequencyOffset(rx,fs,-fOffsetEst);

            % Symbol timing and channel estimate
            preamblefield = rx(pktStartOffset+1:pktStartOffset+ind.DMGHeader(2),:);
            [symbolTimingOffset,chanEst] = dmgTimingAndChannelEstimate(preamblefield);
            startOffset = pktStartOffset+symbolTimingOffset;

            % If not enough samples to decode detected data field start,
            % then assume synchronization error and packet error
            if (startOffset+ind.DMGData(2))>size(rx,1)
                numPacketErrors = numPacketErrors+1;
                numPkt = numPkt+1;
                continue; % Go to next loop iteration

            % Noise estimation using the STF as repeating sequence
            stf = rx(pktStartOffset+(ind.DMGSTF(1):ind.DMGSTF(2)));
            nVarEst = dmgSTFNoiseEstimate(stf);

            % Extract data field (ignore first GI)
            rxData = rx(startOffset+((ind.DMGData(1)+Ngi):ind.DMGData(2)));

            % Linear frequency domain equalization
            rxEqDataBlks = dmgSingleCarrierFDE(rxData,chanEst,nVarEst);

            % Unique word phase tracking
            rxEqDataBlks = dmgUniqueWordPhaseTracking(rxEqDataBlks);

            % Discard GI from all blocks
            rxDataSym = rxEqDataBlks(1:end-Ngi,:);

            % Recover the transmitted PSDU from DMG Data field
            dataDecode = wlanDMGDataBitRecover(rxDataSym,nVarEst,cfgDMG);

            % Determine if any bits are in error, i.e. a packet error
            packetError = any(biterr(psdu,dataDecode));
            numPacketErrors = numPacketErrors+packetError;
            numPkt = numPkt+1;

        % Calculate packet error rate (PER) at SNR point
        packetErrorRate(imcs,isnr) = numPacketErrors/(numPkt-1);
        disp(join(["     MCS:" cfgDMG.MCS ", SNR " ...
            num2str(snr(isnr)) " completed after " ...
            num2str(numPkt-1) " packets, PER: " ...
     MCS:9, SNR 6 completed after 11 packets, PER: 1
     MCS:9, SNR 6.5 completed after 16 packets, PER: 0.6875
     MCS:9, SNR 7 completed after 88 packets, PER: 0.125
     MCS:9, SNR 7.5 completed after 100 packets, PER: 0.01
     MCS:9, SNR 8 completed after 100 packets, PER: 0
     MCS:9, SNR 8.5 completed after 100 packets, PER: 0

Plot Packet Error Rate vs SNR Results

markers = 'ox*sd^v><ph+ox*sd^v';
color = 'bmcrgbrkymcrgbrkymc';
for imcs = 1:numMCS
    semilogy(snrRanges{mcs(imcs)==validMCS},packetErrorRate(imcs,:).',['-' markers(imcs) color(imcs)]);
    hold on;
grid on;
xlabel('SNR (dB)');
dataStr = arrayfun(@(x)sprintf('MCS %s',x),mcs,'UniformOutput',false);
title('PER for DMG SC-PHY, AWGN channel');

Further Exploration

The number of packets tested at each SNR point is controlled by two parameters; maxNumErrors and maxNumPackets. For meaningful results, it is recommended that these values should be larger than those presented in this example. Increasing the number of packets simulated allows the PER under different scenarios to be compared. Try changing the MCS value and compare the packet error rate. As an example, the figure below was created by running the example for all single carrier MCS with PSDULength: 8192 bytes, maxNumErrors: 1000 and maxNumPackets: 10000.


This example uses the following helper functions:

Selected Bibliography

  1. IEEE Std 802.11ad™-2012 IEEE Standard for Information technology - Telecommunications and information exchange between systems - Local and metropolitan area networks - Specific requirements - Part 11: Wireless LAN Medium Access Control (MAC) and Physical Layer (PHY) Specifications. Amendment 3: Enhancements for Very High Throughput in the 60 GHz Band.