802.11ac transmitter measurements -凯发k8网页登录

cfgvht = wlanvhtconfig;            % create packet configuration
cfgvht.channelbandwidth = 'cbw80'; % 80 mhz
cfgvht.numtransmitantennas = 1;    % one transmit antenna
cfgvht.numspacetimestreams = 1;    % one space-time stream
cfgvht.stbc = false;               % no stbc so one spatial stream
cfgvht.mcs = 8;                    % modulation: 256-qam
cfgvht.apeplength = 3000;          % a-mpdu length pre-eof padding in bytes

osf = 3;          % 3x oversampling factor
numpackets = 20;  % generate 20 packets
idletime = 10e-6; % 10 microseconds idle time between packets

% create random data; psdulength is in bytes
savedstate = rng(0); % set random state
data = randi([0 1],cfgvht.psdulength*8*numpackets,1);
% generate a multi-packet waveform
txwaveform = wlanwaveformgenerator(data,cfgvht, ...
    'oversamplingfactor',osf,'numpackets',numpackets,'idletime',idletime);
fs = wlansamplerate(cfgvht); % baseband sampling rate of the waveform

modeliqimbalance = true; % set to true to add iq gain and phase imbalance
if modeliqimbalance
    iqgaindb = 1; % iq gain imbalance in db, specify from the range [-1 1]
    iqphasedeg = 1; % iq phase imbalance in degrees, specify from the range [-2 2]
    iqgainlin = db2mag(iqgaindb); % convert gain from db to linear value
    txwaveform = real(txwaveform)   1i*imag(txwaveform)*iqgainlin*exp(1j*iqphasedeg*pi/180); % as specified in equation-1 of [5]
end

psaturation = 25; % saturation power of a power amplifier in dbm
hpabackoff = 13; % power amplifier backoff in db
% create and configure a memoryless nonlinearity to model the amplifier
nonlinearity = comm.memorylessnonlinearity;
nonlinearity.method = 'rapp model';
nonlinearity.smoothness = 3; % p parameter
nonlinearity.lineargain = -hpabackoff;
nonlinearity.outputsaturationlevel = db2mag(psaturation-30);
% apply the model to each transmit antenna
txwaveform = nonlinearity(txwaveform);

thnoise = comm.thermalnoise('noisemethod','noise figure','samplerate',fs*osf,'noisefigure',6);
for i = 1:cfgvht.numtransmitantennas
    txwaveform(:,i) = thnoise(txwaveform(:,i));
end

astop = 40; % stopband attenuation
ofdminfo = wlanvhtofdminfo('vht-data',cfgvht); % ofdm parameters
scs = fs/ofdminfo.fftlength; % subcarrier spacing
txbw = max(abs(ofdminfo.activefrequencyindices))*2*scs; % occupied bandwidth
[l,m] = rat(1/osf);
maxlm = max([l m]);
r = (fs-txbw)/fs;
tw = 2*r/maxlm; % transition width
firdec = designmultiratefir(l,m,tw,astop,'systemobject',true);

rxwaveform = firdec(txwaveform);

% setup evm measurements
[evmperpkt,evmpersc] = vhtevmsetup(cfgvht);

% get indices for accessing each field within the time-domain packet
ind = wlanfieldindices(cfgvht);
rxwaveformlength = size(rxwaveform,1);
pktlength = double(ind.vhtdata(2));
% define the minimum length of data we can detect; length of the l-stf in
% samples
minpktlen = double(ind.lstf(2)-ind.lstf(1)) 1;
% setup the measurement plots
[hsf,hcon,hevm] = vhttxsetupplots(cfgvht);
rmsevm = zeros(numpackets,1);
pktoffsetstore = zeros(numpackets,1);
rng(savedstate); % restore random state

pktnum = 0;
searchoffset = 0; % start at first sample (no offset)
while (searchoffset minpktlen)<=rxwaveformlength
    % packet detect
    pktoffset = wlanpacketdetect(rxwaveform,cfgvht.channelbandwidth);
    % packet offset from start of waveform
    pktoffset = searchoffset pktoffset;
    % if no packet detected or offset outwith bounds of waveform then stop
    if isempty(pktoffset) || (pktoffset<0) || ...
            ((pktoffset ind.lsig(2))>rxwaveformlength)
        break;
    end
    % extract non-ht fields and perform coarse frequency offset correction
    % to allow for reliable symbol timing
    nonht = rxwaveform(pktoffset (ind.lstf(1):ind.lsig(2)),:);
    coarsefreqoff = wlancoarsecfoestimate(nonht,cfgvht.channelbandwidth);
    nonht = frequencyoffset(nonht,fs,-coarsefreqoff);
    % determine offset between the expected start of l-ltf and actual start
    % of l-ltf
    lltfoffset = wlansymboltimingestimate(nonht,cfgvht.channelbandwidth);
    % determine packet offset
    pktoffset = pktoffset lltfoffset;
    % if offset is without bounds of waveform skip samples and continue
    % searching within remainder of the waveform
    if (pktoffset<0) || ((pktoffset pktlength)>rxwaveformlength)
        searchoffset = pktoffset double(ind.lstf(2)) 1;
        continue;
    end
    % timing synchronization complete; extract the detected packet
    rxpacket = rxwaveform(pktoffset (1:pktlength),:);
    pktnum = pktnum 1;
    disp(['  packet ' num2str(pktnum) ' at index: ' num2str(pktoffset 1)]);
    % apply coarse frequency correction to the extracted packet
    rxpacket = frequencyoffset(rxpacket,fs,-coarsefreqoff);
    % perform fine frequency offset correction on the extracted packet
    lltf = rxpacket(ind.lltf(1):ind.lltf(2),:); % extract l-ltf
    finefreqoff = wlanfinecfoestimate(lltf,cfgvht.channelbandwidth);
    rxpacket = frequencyoffset(rxpacket,fs,-finefreqoff);
    % extract vht-ltf samples, demodulate and perform channel estimation
    vhtltf = rxpacket(ind.vhtltf(1):ind.vhtltf(2),:);
    vhtltfdemod = wlanvhtltfdemodulate(vhtltf,cfgvht);
    % channel estimate and single stream channel estimate
    [chanest,chanestsspilots] = wlanvhtltfchannelestimate(vhtltfdemod,cfgvht);
    % perform iq gain and phase imbalance estimation
    [gainest,phaseest,alphaest,betaest,gamma,datarot] = ...
        helperiqimbalanceestimate(chanest,cfgvht);
    fprintf('    measured iq gain & phase imbalance: %2.2f db, %2.2f deg\n',gainest,phaseest);
    % perform iq gain and phase imbalance correction on channel
    % estimates
    chanest = chanest./(alphaest   betaest.*gamma); % as specified in equation-29 of [5]
    % spectral flatness test
    [pass,deviation,testsc] = wlanspectralflatness(chanest,'vht',cfgvht.channelbandwidth);
    if pass
        disp('    spectral flatness passed');
    else
        disp('    spectral flatness failed');
    end
    % plot deviation against limits
    vhttxplotspectralflatness(deviation,testsc,pktnum,hsf);
    % extract vht data samples from the waveform
    vhtdata = rxpacket(ind.vhtdata(1):ind.vhtdata(2),:);
    % estimate the noise power in vht data field
    noisevarvht = vhtnoiseestimate(vhtdata,chanestsspilots,cfgvht);
    % extract vht data samples and perform ofdm demodulation, equalization
    % and phase tracking
    [~,~,eqsym] = wlanvhtdatarecover(vhtdata,chanest,noisevarvht,cfgvht,...
        'equalizationmethod','zf','pilotphasetracking','preeq','ldpcdecodingmethod','norm-min-sum'); % use zero forcing algorithm for equalization
    % perform iq gain and phase imbalance correction on vht data
    eqsym = eqsym.*datarot; % carrier rotation on data subcarriers
    eqsym = ((conj(alphaest)*eqsym)-(betaest*conj(eqsym(end:-1:1,:,:))))/((abs(alphaest)^2)-(abs(betaest)^2));  % as specified in equation-30 of [5]
    % compute rms evm over all spatial streams for packet
    rmsevm(pktnum) = evmperpkt(eqsym);
    fprintf('    rms evm: %2.2f%%, %2.2fdb\n',rmsevm(pktnum),20*log10(rmsevm(pktnum)/100));
    % compute rms evm per subcarrier and spatial stream for the packet
    evmpersc = evmpersc(eqsym); % nst-by-1-by-nss
    % plot rms evm per subcarrier and equalized constellation
    vhttxevmconstellationplots(eqsym,evmpersc,cfgvht,pktnum,hcon,hevm);
    % store the offset of each packet within the waveform
    pktoffsetstore(pktnum) = pktoffset;
    % increment waveform offset and search remaining waveform for a packet
    searchoffset = pktoffset pktlength minpktlen;
end

if pktnum>0
    fprintf('average evm for %d packets: %2.2f%%, %2.2fdb\n', ...
        pktnum,mean(rmsevm(1:pktnum)),20*log10(mean(rmsevm(1:pktnum))/100));
else
    disp('no complete packet detected');
end

% indices for accessing each field within the time-domain packet
ind = wlanfieldindices(cfgvht,'oversamplingfactor', osf);
startidx = ind.vhtdata(1); % start of data
endidx = ind.vhtdata(2);   % end of data
idlensamps = idletime*fs*osf; % idle time samples
perpktlength = endidx idlensamps;
idx = zeros(endidx-startidx 1,numpackets);
for i = 1:numpackets
    % start of packet in txwaveform, accounting for the filter delay
    pktoffset = (i-1)*perpktlength;
    % indices of non-ht data in txwaveform
    idx(:,i) = pktoffset (startidx:endidx);
end
gatedvhtdata = txwaveform(idx(:),:);

if pktnum>0
    helperspectralmasktest(gatedvhtdata,fs,osf);
end