802.11ax phy-凯发k8网页登录

calibrate = true;             % to execute part a calibration test
systemlevelsimulation = true; % to execute part b system-level simulation
showscenarioplot = true;      % to show dynamic simulation plotting updates

phyparameters = struct;
phyparameters.txpower = 20;      % transmitter power in dbm
phyparameters.txgain = 0;        % transmitter antenna gain in dbi
phyparameters.rxgain = -2;       % receiver antenna gain in dbi
phyparameters.noisefigure = 7;   % receiver noise figure in db
phyparameters.numtxantennas = 1; % number of transmitter antennas
phyparameters.numrxantennas = 1; % number of receiver antennas
phyparameters.channelbandwidth = 'cbw80'; % bandwidth of system
phyparameters.transmitterfrequency = 5e9; % transmitter frequency in hz
macparameters = struct;
macparameters.numchannels = 3; % number of non-overlapping channels
macparameters.ccalevel = -70;  % transmission threshold in cca algorithm (dbm)

% number of rooms in [x,y,z] directions
scenarioparameters = struct;
scenarioparameters.buildinglayout = [10 2 5];
% size of each room in meters [x,y,z]
scenarioparameters.roomsize = [10 10 3];
% number of receivers per room. note that only one receiver (sta) can be
% active at any given time.
scenarioparameters.numrxperroom = 1;

simparameters = struct;
simparameters.numdrops = 3;
simparameters.numtxeventsperdrop = 2;

% total number of transmitters, assuming one transmitter (tx) per room
numtx = prod(scenarioparameters.buildinglayout);
% create transmitter sites with and isotropic antenna element
roomnames = strings(1,numtx);
for siteind = 1:numtx
    roomnames(siteind) = "room "   siteind;
end
txs = txsite('cartesian','name',roomnames,...
    'transmitterfrequency',phyparameters.transmitterfrequency, ...
    'transmitterpower',10.^((phyparameters.txpower phyparameters.txgain-30)/10),...
    'antenna','isotropic');

% total number of receivers, assuming one transmitter (tx) per room
numrx = numtx*scenarioparameters.numrxperroom;
% create receiver sites
roomnames = strings(1,numrx);
for siteind = 1:numrx
    roomnames(siteind) = "room "   (mod(siteind-1,numtx) 1)   "-"   ceil(siteind/numtx);
end
rxs = rxsite('cartesian','name',roomnames,'antenna','isotropic');
% receiver noise power in dbm
t = 290; % temperature (kelvin)
k = physconst('boltzmann'); % boltzmann constant
% sample rate (hz)
fs = wlansamplerate(wlanhesuconfig('channelbandwidth',phyparameters.channelbandwidth));
rxnoisepower = 10*log10(k*t*fs) 30 phyparameters.noisefigure;

seed = rng(6); % seed random number generator and store state
if showscenarioplot
    hgrid = tgaxbuildresidentialgrid(scenarioparameters.roomsize,scenarioparameters.buildinglayout, ...
        numtx,numrx,macparameters.numchannels);
end
if calibrate
fprintf('running calibration ...\n');
% pre-allocate output
output = struct;
output.sinr = zeros(simparameters.numdrops,numtx); % for storing sinr values
for drop = 1:simparameters.numdrops
    % drop receivers in each room
    [association,txchannels,rxchannels,txpositions,rxpositions] = tgaxdropnodes( ...
        txs,rxs,scenarioparameters,macparameters.numchannels);
    % all transmitters active
    activetx = true(numtx,1);
    % only pick one receiver per room
    rxalloc = randi([1 scenarioparameters.numrxperroom],numtx,1);
    activerx = reshape(rxalloc==1:scenarioparameters.numrxperroom,[],1);
    % generate propagation model
    propmodel = tgaxresidential('roomsize',scenarioparameters.roomsize);
    % get the index of the transmitter for each receiver
    tnum = repmat((1:numtx),1,numrx/numtx);
    % sinr calculation - loop over each non-overlapping channel
    activechannels = unique(txchannels);
    for k = 1:numel(activechannels)
        % use kth non-overlapping channel
        tind = txchannels == activechannels(k);
        rind = false(size(activerx));
        rind(activerx) = rxchannels(activerx) == activechannels(k);
        % get the index of the transmitter of interest for each active receiver
        tsigind = tnum(rind);
        % calculate snr
        output.sinr(drop,tind) = sinr(rxs(rind),txs(tind),...
            'receivergain',phyparameters.rxgain,...
            'receivernoisepower',rxnoisepower,...
            'propagationmodel',propmodel,...
            'signalsource',txs(tsigind));
    end
    % plot nodes and links
    if showscenarioplot % update plot data
        mask = txchannels==rxchannels';
        tgaxupdateplot(hgrid,txpositions,rxpositions,activetx,activerx,mask,txchannels,rxchannels, ...
            sprintf('box 1 test 2 "downlink only" calibration, drop #%d/%d',drop,simparameters.numdrops));
    end
end
% plot the cdf of sinr and compare with calibration curves
tgaxcalibrationcdf(output.sinr,'ss1box1test2','long-term radio characteristics');
fprintf('calibration complete \n')
end

if systemlevelsimulation
% pre-allocate outputs
output.numpkts = zeros(numrx,1);
output.numpkterrors = zeros(numrx,1);
output.sinrmeas = nan(numrx,simparameters.numtxeventsperdrop,simparameters.numdrops);
output.sinrest = nan(numrx,simparameters.numtxeventsperdrop,simparameters.numdrops);
output.pkterrorrate = 0;
% for each possible transmitter create a waveform configuration. in this
% example the link and radio parameters are the same for all nodes.
cfghebase = wlanhesuconfig;
cfghebase.channelbandwidth = phyparameters.channelbandwidth; % channel bandwidth
cfghebase.numtransmitantennas = phyparameters.numtxantennas; % number of transmit antennas
cfghebase.spatialmapping = 'fourier';  % spatial mapping matrix
cfghebase.numspacetimestreams = 1;     % number of space-time streams
cfghebase.guardinterval = 0.8;         % guard interval duration
cfghebase.heltftype = 4;               % he-ltf compression mode
cfghebase.apeplength = 1e3;            % payload length in bytes
cfghebase.channelcoding = 'ldpc';      % channel coding
cfghebase.mcs = 3;                     % modulation and coding scheme
cfghe = cell(numtx,1);
for txidx = 1:numtx
    cfghe{txidx} = cfghebase;
end
fprintf('running system level simulation ...\n')
for drop = 1:simparameters.numdrops
    fprintf('  running drop #%d/%d ...\n',drop,simparameters.numdrops);
    % drop receivers in each room
    [association,txchannels,rxchannels,txpositions,rxpositions] = tgaxdropnodes( ...
        txs,rxs,scenarioparameters,macparameters.numchannels);
    % generate propagation model
    propmodel = tgaxresidential('roomsize',scenarioparameters.roomsize);
    % calculate signal strength for all links
    signalstrength = sigstrength(rxs,txs,propmodel,'type','power',...
        'receivergain',phyparameters.rxgain); % all signal strengths in dbm
    % threshold signals below noise level to reduce simulation time
    signalstrength(signalstrength < rxnoisepower) = -inf;
    % threshold signals that are not on same non-overlapping channel
    signalstrength(~(txchannels == rxchannels')) = -inf;
    % mask the transmitter-receiver links that are non-negligible to
    % simulate and get the linear indices
    nonnegligiblemask = signalstrength > -inf;
    % reset the non-negligible channels to create a new realization for the
    % current drop
    nonnegligibleidx = find(nonnegligiblemask)';
    % for each possible active link in a drop create a channel
    % configuration. in this example the link and radio parameters are the
    % same for all nodes.
    tgaxchan = cell(numel(nonnegligibleidx),1);
    for i = 1:numel(nonnegligibleidx)
        % index of transmitter for a given link
        txidx = mod(nonnegligibleidx(i)-1,numtx) 1;
        % channel configuration. the channel realization for each link is
        % different as the global random stream is used.
        tgaxchanbase = wlantgaxchannel;
        tgaxchanbase.delayprofile = 'model-d';
        tgaxchanbase.numtransmitantennas = cfghe{txidx}.numtransmitantennas;
        tgaxchanbase.numreceiveantennas = phyparameters.numrxantennas;
        tgaxchanbase.transmitreceivedistance = 10; % distance in meters for nlos
        tgaxchanbase.channelbandwidth = cfghe{txidx}.channelbandwidth;
        tgaxchanbase.largescalefadingeffect = 'none';
        tgaxchanbase.environmentalspeed = 0; % m/s, stationary
        tgaxchanbase.samplerate = fs;
        tgaxchanbase.normalizechanneloutputs = false;
        % store in cell array and reset the channel to generate a new
        % response
        tgaxchan{i} = tgaxchanbase;
        reset(tgaxchan{i});
    end
    for txevent = 1:simparameters.numtxeventsperdrop
        fprintf('    running transmission event #%d/%d ...\n',txevent,simparameters.numtxeventsperdrop);
        % determine active transmitters and receivers with clear channel assessment
        [activetx,activerx] = tgaxcca(signalstrength,macparameters.ccalevel);
        % plot scenario and links
        if showscenarioplot
            tgaxupdateplot(hgrid,txpositions,rxpositions,activetx,activerx,nonnegligiblemask,txchannels,rxchannels, ...
                sprintf('phy system-level simulation, drop #%d/%d, transmission event #%d/%d', ...
                drop,simparameters.numdrops,txevent,simparameters.numtxeventsperdrop));
        end
        % extract elements for active links using activetx and activerx
        cfgheactive = cfghe(activetx);
        associationactive = association(activetx,activerx);
        nonnegligiblemaskactive = nonnegligiblemask(activetx,activerx);
        signalstrengthactive = signalstrength(activetx,activerx);
        % create array containing active channels
        tgaxchanactive = cell(size(associationactive));
        matchidx = nonnegligibleidx==find(activetx&activerx');
        tgaxchanactive(nonnegligiblemaskactive) = tgaxchan(any(matchidx,1));
        % generate a waveform for each non-negligible active link and
        % combine waveforms for each receiver
        [rxwavs,txpsduactive,signalpower,interfpower] = tgaxgeneraterxwaveforms( ...
            cfgheactive,tgaxchanactive,nonnegligiblemaskactive,signalstrengthactive,associationactive);
        % run phy link simulation for each link and determine if the packet
        % has been decoded successfully. the estimated interference power
        % is passed to the receiver in the place of an interference power
        % measurement algorithm.
        numactiverxs = sum(activerx);
        pkterror = false(numactiverxs,1);
        sinrmeas = nan(numactiverxs,1);
        for rxidx = 1:numactiverxs
            [pkterror(rxidx),sinrmeas(rxidx)] = tgaxmodelphylink( ...
                rxwavs{rxidx},cfgheactive{rxidx},rxnoisepower,interfpower(rxidx),txpsduactive{rxidx});
        end
        % store output for active receivers
        output.numpkterrors(activerx) = output.numpkterrors(activerx) pkterror;
        output.numpkts(activerx) = output.numpkts(activerx)   1;
        output.sinrmeas(activerx,txevent,drop) = sinrmeas;
        % calculate the expected sinr at each receiver
        sinrest = 10*log10(signalpower./(interfpower 10^((rxnoisepower-30)/10)));
        output.sinrest(activerx,txevent,drop) = sinrest;
    end
end
% calculate average packet error rate
output.pkterrorrate = sum(output.numpkterrors)/sum(output.numpkts);
disp('simulation complete')
disp(['average packet error rate for transmitters: ' num2str(output.pkterrorrate)]);
end
rng(seed); % restore random state