Документация

numTrBlks = 5;              % Number of simulated transport blocks
SNRdB = [-20 -18 -15 -12.5 -10 -6.4 -3.5 0.7];  % Range of SNR values in dB
simReps = [2 16 64];        % Repetitions to simulate

ue = struct();                        % Initialize the UE structure
ue.NBULSubcarrierSpacing = '15kHz';   % 3.75kHz, 15kHz
ue.NNCellID = 10;                     % Narrowband cell identity

chs = struct();
chs.NPUSCHFormat = 'Data';        % NPUSCH payload type ('Data' or 'Control')
% The number of subcarriers used for NPUSCH 'NscRU' depends on the NPUSCH
% format and subcarrier spacing 'NBULSubcarrierSpacing' as shown in TS 36.211
% Table 10.1.2.3-1. There are 1,3,6 or 12 continuous subcarriers for NPUSCH
chs.NBULSubcarrierSet = 0:11;     % Range is 0-11 (15kHz); 0-47 (3.75kHz)
chs.NRUsc = length(chs.NBULSubcarrierSet);
% The symbol modulation depends on the NPUSCH format and NscRU as given by
% TS 36.211 Table 10.1.3.2-1
chs.Modulation = 'QPSK';
chs.CyclicShift = 0;        % Cyclic shift required when NRUsc = 3 or 6
chs.RNTI = 20;              % RNTI value
chs.NLayers = 1;            % Number of layers
chs.NRU = 1;                % Number of resource units
chs.SlotIdx = 0;            % The slot index
chs.NTurboDecIts = 5;       % Number of turbo decoder iterations

% RV offset signaled via DCI (See 36.213 16.5.1.2)
rvDCI = 0;
% Calculate the RVSeq used according to the RV offset
rvSeq = [2*mod(rvDCI+0,2)  2*mod(rvDCI+1,2)];

if strcmpi(chs.NPUSCHFormat,'Data')
    infoLen = 136;   % Transport block size for NPUSCH format 1
elseif strcmpi(chs.NPUSCHFormat,'Control')
    if ~strcmpi(chs.Modulation,'BPSK')
        error('For NPUSCH format 2 (Control), the modulation must be BPSK');
    end
    infoLen = 1;    % ACK/NACK bit for NPUSCH format 2
    if length(chs.NBULSubcarrierSet) ~= 1
        error('The number of subcarriers must be 1 for control information');
    end
end

channel = struct;                    % Initialize channel config structure
channel.Seed = 6;                    % Channel seed
channel.NRxAnts = 2;                 % 2 receive antennas
channel.DelayProfile ='ETU';         % Delay profile
channel.DopplerFreq = 1;             % Doppler frequency in Hz
channel.MIMOCorrelation = 'Low';     % Multi-antenna correlation
channel.NTerms = 16;                 % Oscillators used in fading model
channel.ModelType = 'GMEDS';         % Rayleigh fading model type
channel.InitPhase = 'Random';        % Random initial phases
channel.NormalizePathGains = 'On';   % Normalize delay profile power
channel.NormalizeTxAnts = 'On';      % Normalize for transmit antennas

chs.SeqGroupHopping = true; % Enable/Disable Sequence-Group Hopping for UE
chs.Deltass = 0;            % Higher-layer parameter groupAssignmentNPUSCH

% Get number of time slots in a resource unit NULSlots
if strcmpi(chs.NPUSCHFormat,'Data')
    if strcmpi(ue.NBULSubcarrierSpacing,'3.75kHz')
        chs.NULSlots = 16;
    elseif strcmpi(ue.NBULSubcarrierSpacing,'15kHz')
        if chs.NRUsc == 12
            chs.NULSlots = 2;
        elseif chs.NRUsc == 6
            chs.NULSlots = 4;
        elseif chs.NRUsc == 3
            chs.NULSlots = 8;
        elseif chs.NRUsc == 1
            chs.NULSlots = 16;
        else
            error('Invalid number of subcarriers (%d), should be one of 1,3,6,12',chs.NRUsc);
        end
    else
        error('Invalid subcarrier spacing (%s), should be either 3.75kHz or 15kHz',ue.NBULSubcarrierSpacing);
    end
elseif strcmpi(chs.NPUSCHFormat,'Control')
    chs.NULSlots = 4;
else
    error('Invalid NPUSCH Format (%s), should be either Data or Control',chs.NPUSCHFormat);
end

% Get the slot grid and number of slots per frame
if strcmpi(ue.NBULSubcarrierSpacing,'15kHz')
    slotGridSize = [12, 7];
    NSlotsPerFrame = 20;      % Slots 0...19
    tSlot = 5e-4;
else
    slotGridSize = [48, 7];
    NSlotsPerFrame = 5;       % Slots 0...4
    tSlot = 0.02;
end

for repIdx = 1:numel(simReps)

    chs.NRep = simReps(repIdx); % Number of repetitions of the NPUSCH
    NSlotsPerBundle = chs.NRU*chs.NULSlots*chs.NRep; % Number of slots in a codeword bundle
    TotNSlots = numTrBlks*NSlotsPerBundle;   % Total number of simulated slots

    % Initialize BLER and throughput result
    maxThroughput = zeros(length(SNRdB),1);
    simThroughput = zeros(length(SNRdB),1);
    bler = zeros(1,numel(SNRdB)); % Initialize BLER result

    % The temporary variables 'ue_init', 'chs_init' and 'channel_init' are used to create
    % the temporary variables 'ue', 'chs' and 'channel' within the SNR loop to create
    % independent simulation loops for the 'parfor' loop
    ue_init = ue;
    chs_init = chs;
    channel_init = channel;

    for snrIdx = 1:numel(SNRdB)
    % parfor snrIdx = 1:numel(SNRdB)
    % To enable the use of parallel computing for increased speed comment out
    % the 'for' statement above and uncomment the 'parfor' statement below.
    % This needs the Parallel Computing Toolbox (TM). If this is not installed
    % 'parfor' will default to the normal 'for' statement.

        % Set the random number generator seed depending on the loop variable
        % to ensure independent random streams
        rng(snrIdx,'combRecursive');

        ue = ue_init;     % Initialize ue configuration
        chs = chs_init;   % Initialize chs configuration
        channel = channel_init; % Initialize fading channel configuration
        numBlkErrors = 0; % Number of transport blocks with errors
        dstateULSCH = []; % UL-SCH, need to be re-initialized for each trblk
        estate = [];      % Initialize NPDSCH encoder state
        dstate = [];      % Initialize NPDSCH decoder state
        trblk = [];       % Initialize the transport block
        txgrid = [];      % Full grid initialization
        statedmrs = [];   % DM-RS state

        % Display the number of slots being generated
        fprintf('\nGenerating %d slots corresponding to %d transport block(s) at %gdB SNR\n',TotNSlots,numTrBlks,SNRdB(snrIdx));

        for slotIdx = 0+(0:TotNSlots-1)
            % Calculate the frame number and slot number within the frame
            ue.NFrame = fix(slotIdx/NSlotsPerFrame);
            ue.NSlot = mod(slotIdx,NSlotsPerFrame);
            % Create the slot grid
            slotGrid = zeros(slotGridSize);

            if isempty(trblk)
               if strcmpi(chs.NPUSCHFormat,'Data')
                   % UL-SCH encoding is performed for the two RV values used for
                   % transmitting the codewords. The RV sequence used is determined
                   % from the rvDCI value signaled in the DCI and alternates
                   % between 0 and 2 as given in TS 36.213 Section 16.5.1.2

                   % Define the transport block which will be encoded to create the
                   % codewords for different RV
                   trblk = randi([0 1],infoLen,1);

                   % Determine the coded transport block size
                   [~, info] = hNPUSCHIndices(ue,chs);
                   outblklen = info.G;
                   % Create the codewords corresponding to the two RV values used
                   % in the first and second block, this will be repeated till all
                   % blocks are transmitted
                   chs.RV = rvSeq(1); % RV for the first block
                   cw = hNULSCH(chs,outblklen,trblk); % CRC and Turbo coding is repeated
                   chs.RV = rvSeq(2); % RV for the second block
                   cw = [cw hNULSCH(chs,outblklen,trblk)]; %#ok<AGROW> % CRC and Turbo coding is repeated
               else
                   trblk = randi([0 1],1); % 1 bit ACK
                   % For ACK, the same codeword is transmitted every block as
                   % defined in TS 36.212 Section 6.3.3
                   cw = hNULSCH(trblk);
               end
               blockIdx = 0; % First block to be transmitted
            end

            % Set the RV used for the current transport block
            chs.RV = rvSeq(mod(blockIdx,size(rvSeq,2))+1);

            % NPUSCH encoding and mapping onto the slot grid
            [txsym, estate] = hNPUSCH(ue,chs,cw(:,mod(blockIdx,size(cw,2))+1),estate);
            slotGrid(hNPUSCHIndices(ue,chs)) = txsym;
            % NPUSCH DRS and mapping on to the slot grid
            [dmrs,statedmrs] = hNPUSCHDRS(ue,chs,statedmrs);
            slotGrid(hNPUSCHDRSIndices(ue,chs)) = dmrs;

            % If a full block is transmitted, increment the clock counter so that
            % the correct codeword can be selected
            if estate.EndOfBlk
                blockIdx = blockIdx + 1;
            end

            % Perform SC-FDMA modulation to create the time domain waveform
            [txWaveform,scfdmaInfo] = lteSCFDMAModulate(ue,chs,slotGrid);

            % Add 25 sample padding. This is to cover the range of delays
            % expected from channel modeling (a combination of
            % implementation delay and channel delay spread)
            txWaveform =  [txWaveform; zeros(25, size(txWaveform,2))]; %#ok<AGROW>

            % Initialize channel time for each slot
            channel.InitTime = slotIdx*tSlot;

            % Pass data through channel model
            channel.SamplingRate = scfdmaInfo.SamplingRate;
            [rxWaveform,fadingInfo] = lteFadingChannel(channel, txWaveform);

            % Calculate noise gain
            SNR = 10^(SNRdB(snrIdx)/20);

            % Normalize noise power to take account of sampling rate, which is
            % a function of the IFFT size used in SC-FDMA modulation
            N0 = 1/(sqrt(2.0*double(scfdmaInfo.Nfft))*SNR);

            % Create additive white Gaussian noise
            noise = N0*complex(randn(size(rxWaveform)), ...
                                randn(size(rxWaveform)));

            % Add AWGN to the received time domain waveform
            rxWaveform = rxWaveform + noise;

            %------------------------------------------------------------------
            %            Receiver
            %------------------------------------------------------------------

            % Perform timing synchronization, extract the appropriate
            % subframe of the received waveform, and perform OFDM
            % demodulation
            offset  = hPerfectTimingEstimate(fadingInfo);

            % Synchronize the received waveform
            rxWaveform = rxWaveform(1+offset:end, :);

            % Perform SC-FDMA demodulation on the received data to recreate the
            % resource grid
            rxSlot = lteSCFDMADemodulate(ue,chs,rxWaveform);

            % Perfect channel estimation
            ue.TotSlots = 1; % Channel estimate for 1 slot
            estChannelGrid = lteULPerfectChannelEstimate(ue,chs,channel, offset);
            noiseGrid = lteSCFDMADemodulate(ue,chs,noise(1+offset:end ,:));
            noiseEst = var(noiseGrid(:));

            % Get NPUSCH indices
            npuschIndices = hNPUSCHIndices(ue,chs);

            % Get NPUSCH resource elements from the received slot
            [rxNpdschSymbols, npdschHest] = lteExtractResources(npuschIndices, ...
                rxSlot, estChannelGrid);

            % Decode NPUSCH
            [rxcw,dstate,symbols] = hNPUSCHDecode(...
                                 ue, chs, rxNpdschSymbols, npdschHest, noiseEst,dstate);

            % Decode the transport block when all the slots in a block have
            % been received
            if dstate.EndOfBlk
                % Soft-combining at transport channel decoder
                [out, err, dstateULSCH] = hNULSCHDecode(chs,infoLen,rxcw,dstateULSCH);
            end

            % If all the slots in the bundle have been received, count the
            % errors and reinitialize for the next bundle
            if dstate.EndOfTx
               if strcmpi(chs.NPUSCHFormat,'Control')
                   err = ~isequal(out,trblk);
               end
               numBlkErrors = numBlkErrors + err;
               % Re-initialize to enable the transmission of a new transport
               % block
               trblk = [];
               dstateULSCH = [];
               statedmrs = [];
            end
        end
        % Calculate the block error rate
        bler(snrIdx) = numBlkErrors/numTrBlks;
        fprintf('NPUSCH BLER = %.4f \n',bler(snrIdx));
        % Calculate the maximum and simulated throughput
        maxThroughput(snrIdx) = infoLen*numTrBlks; % Max possible throughput
        simThroughput(snrIdx) = infoLen*(numTrBlks-numBlkErrors);  % Simulated throughput
        fprintf('NPUSCH Throughput(%%) = %.4f %%\n',simThroughput(snrIdx)*100/maxThroughput(snrIdx));

    end

    % Plot Block Error Rate vs SNR Results
    if repIdx == 1
        figure;
        grid on;
        hold on;
        xlabel('SNR (dB)');
        ylabel('BLER');
        legendstr = {['NRep = ' num2str(chs_init.NRep)]};
    else
        legendstr = [legendstr ['NRep = ' num2str(chs_init.NRep)]]; %#ok<AGROW>
    end
    plot(SNRdB, bler, '-o');


end
% Set figure title
title(sprintf(' NPUSCH Carrying %s: NRUsc = %d, NRU = %d, TBS = %d',...
    chs_init.NPUSCHFormat,chs_init.NRUsc,chs_init.NRU,infoLen));
legend(legendstr);