Documentation

This is machine translation

Translated by Microsoft
Mouseover text to see original. Click the button below to return to the English verison of the page.

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

802.11ad Waveform Generation with Beamforming

  • Products Used
  • WLAN System Toolbox™

This example shows how to simulate beamforming an IEEE® 802.11ad™ DMG waveform with a phased array using WLAN System Toolbox™ and Phased Array System Toolbox™.

This example requires WLAN System Toolbox.

Introduction

IEEE 802.11ad [ 1 ] defines the directional multi-gigabit (DMG) transmission format operating at 60 GHz. To overcome the large path loss experienced at 60 GHz, the IEEE 802.11ad standard is designed to support directional beamforming. By using phased antenna arrays you can apply an antenna weight vector (AWV) to focus the antenna pattern in the desired direction. Each packet is transmitted on all array elements, but the AWV applies phase shift to each element to steer the transmission. The quality of a communication link can be improved by appending optional training fields to DMG packets, and testing different AWVs at the transmitter or receiver. This process is called beam refinement.

A DMG packet consists of the following fields:

  1. STF - The short training field, which is used for synchronization

  2. CE - Channel estimation field, which is used for channel estimation

  3. Header - The signaling field, which the receiver decodes to determine transmission parameters

  4. Data - The data field, which carries the user data payload

  5. AGC Subfields - Optional automatic gain control (AGC) subfields, used for beam refinement

  6. Training Subfields - Optional training subfields, used for beam refinement

The STF and CE fields form the preamble. The preamble, header and data fields of a DMG packet are transmitted with the same AWV. For transmitter beam refinement training, up to 64 training (TRN) subfields can be appended to the packet. Each TRN subfield is transmitted using a different AWV. This allows the performance of up to 64 different AWVs to be measured, and the AWV for the preamble, header and data fields to be refined for subsequent transmissions. CE subfields are periodically transmitted, one for every four TRN subfields, amongst the TRN subfields. Each CE subfield is transmitted using the same AWV as the preamble. To allow the receiver to reconfigure AGC before receiving the TRN subfields, the TRN subfields are preceded by AGC subfields. For each TRN subfield, an AGC subfield is transmitted using the same AWV applied to the individual TRN subfield. This allows a gain to be set at the receiver, suitable to measuring all TRN subfields. The diagram below shows the packet structure with four AGC and TRN subfields numbered and highlighted. Therefore, four AWVs are tested as part of beam refinement. The same AWVs are applied to AGC and TRN subfields with the same number.

In this example transmitter training is simulated by applying different AWVs to each of the training subfields, to steer the transmission in multiple directions. The strength of each training subfield is evaluated at a receiver by evaluating the far-field plane wave, to determine which transmission AWV is optimal. No channel or path loss is simulated in this example.

Waveform Specification

The waveform will be configured for a DMG packet transmission with an OFDM PHY, a 100 byte PSDU, and four transmitter training subfields. The four training subfields allow four AWVs to be tested for beam refinement. Using the WLAN toolbox function wlanDMGConfig, create a DMG configuration object. A DMG configuration object specifies transmission parameters.

dmg = wlanDMGConfig;
dmg.MCS = 13;             % OFDM PHY
dmg.TrainingLength = 4;   % Use 4 training subfields
dmg.PacketType = 'TRN-T'; % Transmitter training
dmg.PSDULength = 100;     % Bytes

Beamforming Specification

The transmitter antenna pattern will be configured as a 16 element uniform linear array with half wavelength spacing. Using the objects phased.ULA and phased.SteeringVector,, create the phased array and the AWVs. The location of the receiver for evaluating the transmission is specified as an offset from the boresight of the transmitter.

receiverAz = 6; % Degrees off the transmitter's boresight

A uniform linear phased array with 16 elements is created to steer the transmission.

N = 16;                            % Number of elements
c = physconst('lightspeed');       % Propagation speed (m/s)
fc = 60.48e9;                      % Center frequency (Hz)
lambda = c/fc;                     % Wavelength (m)
d = lambda/2;                      % Antenna element spacing (m)
TxArray = phased.ULA('NumElements',N,'ElementSpacing',d);

The AWVs are created using a phased.SteeringVector, object. Five steering angles are specified to create five AWVs, one for the preamble and data fields, and one for each of the four the training subfields. The preamble and data fields are transmitted at boresight. The four training subfields are transmitted at angles around boresight.

% Create a directional steering vector object
SteeringVector = phased.SteeringVector('SensorArray',TxArray);

% The directional angle for the preamble and data is 0 degrees azimuth, no
% elevation, therefore at boresight. [Azimuth; Elevation]
preambleDataAngle = [0; 0];

% Each of the four training fields uses a different set of weights to steer
% to a slightly different direction. [Azimuth; Elevation]
trnAngle = [[-10; 0] [-5; 0] [5; 0] [10; 0]];

% Generate the weights for all of the angles
weights = SteeringVector(fc,[preambleDataAngle trnAngle]);

% Each row of the AWV is a weight to apply to a different antenna element
preambleDataAWV = conj(weights(:,1)); % AWV used for preamble, data and CE
                                      % fields
trnAWV = conj(weights(:,2:end));      % AWV used for each TRN subfield

Using the plotArrayResponse subfunction, the array response shows the direction of the receiver is most aligned with the direction of training subfield TRN-SF3.

plotArrayResponse(TxArray,receiverAz,fc,weights);

Generate Baseband Waveform

Use the configured DMG object and a PSDU filled with random data as inputs to the waveform generator, wlanWaveformGenerator. The waveform generator modulates PSDU bits according to a format configuration and also performs OFDM windowing.

% Create a PSDU of random bits
s = rng(0); % Set random seed for repeatable results
psdu = randi([0 1],dmg.PSDULength*8,1);

% Generate packet
tx = wlanWaveformGenerator(psdu,dmg);

Apply Weight Vectors to Each Field

A phased.Radiator, object is created to apply the AWVs to the waveform, combine the radiated signal from each element to form a plane wave, and determine the plane wave at the angle of interest, receiverAz. Each portion of the DMG waveform tx is passed through the Radiator with a specified set of AWVs, and the angle at which to evaluate the plane wave.

Radiator = phased.Radiator;
Radiator.Sensor = TxArray;        % Use the uniform linear array
Radiator.WeightsInputPort = true; % Provide AWV as argument
Radiator.OperatingFrequency = fc; % Frequency in Hertz
Radiator.CombineRadiatedSignals = true; % Create plane wave

% The plane wave is evaluated at a direction relative to the radiator
steerAngle = [receiverAz; 0]; % [Azimuth; Elevation]

% The beamformed waveform is evaluated as a plane wave at the receiver
planeWave = zeros(size(tx));

% Get indices for fields
ind = wlanFieldIndices(dmg);

% Get the plane wave while applying the AWV to the preamble, header, and
% data
idx = (1:ind.DMGData(2));
planeWave(idx) = Radiator(tx(idx),steerAngle,preambleDataAWV);

% Get the plane wave while applying the AWV to the AGC and TRN subfields
for i = 1:dmg.TrainingLength
    % AGC subfields
    agcsfIdx = ind.DMGAGCSubfields(i,1):ind.DMGAGCSubfields(i,2);
    planeWave(agcsfIdx) = Radiator(tx(agcsfIdx),steerAngle,trnAWV(:,i));
    % TRN subfields
    trnsfIdx = ind.DMGTRNSubfields(i,1):ind.DMGTRNSubfields(i,2);
    planeWave(trnsfIdx) = Radiator(tx(trnsfIdx),steerAngle,trnAWV(:,i));
end

% Get the plane wave while applying the AWV to the TRN-CE
for i = 1:dmg.TrainingLength/4
    trnceIdx = ind.DMGTRNCE(i,1):ind.DMGTRNCE(i,2);
    planeWave(trnceIdx) = Radiator(tx(trnceIdx),steerAngle,...
        preambleDataAWV);
end

Evaluate the Beamformed Waveform

The helper function helperPlotDMGWaveform.m plots the magnitude of the beamformed plane wave. When evaluating the magnitude of the beamformed plane wave we can see that the fields beamformed in the direction of the receiver are stronger than other fields.

helperPlotDMGWaveform(planeWave,dmg,...
    'Beamformed plane wave with fields highlighted');

rng(s); % Restore random state

Conclusion

This example showed how to generate an IEEE 802.11ad DMG waveform and apply AWVs to different portions of the waveform. WLAN System Toolbox was used to generate a standard compliant waveform, and Phased Array System Toolbox was used to apply the AWVs and evaluate the magnitude of the resultant plane wave in the direction of a receiver.

Appendix

This example uses the following helper function:

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.

Plot Array Response

function plotArrayResponse(TxArray,receiverAz,fc,weights)
    d = directivity(TxArray,fc,[0 90]); % Broadside and endfire directivity
    [x,y] = pol2cart(deg2rad(receiverAz),d(1)-d(2));
    figure;
    pattern(TxArray,fc,-90:90,0,'Weights',weights); % Plot array pattern
    hold on;
    plot([0 x],[0 y],'r','LineWidth',2); % Plot receiver direction
    numAWV = size(weights,2);
    legendStr = cell(numAWV+1,1); % Create legend
    legendStr{1} = 'Data field weights';
    legendStr(2:end-1) = arrayfun(@(x)sprintf('TRN-SF%d weights',x),...
        1:numAWV-1,'UniformOutput',false);
    legendStr{end} = 'Receiver direction';
    legend(legendStr);
end
Was this topic helpful?