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

% Burst configuration related to the burst structure itself:
burst.BlockPattern = 'Case B';
burst.SSBPeriodicity = 20;
burst.NFrame = 4;
burst.SSBTransmitted = [1 1 1 1 1 1 1 1];
burst.NCellID = 102;

% Burst configuration related to carrier (10 MHz, see TS 38.104 Table
% 5.3.2-1):
gnb.SubcarrierSpacing = 15;
gnb.NRB = 52;
gnb.CyclicPrefix = 'Normal';
carrierInfo = hOFDMInfo(gnb);
burst.SampleRate = carrierInfo.SamplingRate;
K = carrierInfo.NSubcarriers;
burst.FrequencyPointA = -K/2 * gnb.SubcarrierSpacing * 1e3;

% Burst configuration related to MIB content:
burst.DMRSTypeAPosition = 2;
burst.PDCCHConfigSIB1 = 17;
burst.CellBarred = 0;
burst.IntraFreqReselection = 0;
burst.SubcarrierSpacingCommon = carrierInfo.SubcarrierSpacing;
burst.DisplayBurst = true;

% Configure number of transmit and receive antennas
ntxants = 8;
nrxants = 2;

% Configure channel
velocity = 30.0;
fc = 4e9;
c = physconst('lightspeed');
fd = (velocity*1000/3600)/c*fc;
channel = nrTDLChannel;
channel.Seed = 24;
channel.DelayProfile = 'TDL-C';
channel.DelaySpread = 300e-9;
channel.MaximumDopplerShift = fd;
channel.MIMOCorrelation = 'Medium';
channel.Polarization = 'Cross-Polar';
channel.NumTransmitAntennas = ntxants;
channel.NumReceiveAntennas = nrxants;

% Configure SNR for AWGN
SNRdB = 10;

% Display burst
disp(burst);

% Create and display burst information
burstInfo = hSSBurstInfo(burst);
disp(burstInfo);

% Create burst resource grid
[~,burstGrid] = hSSBurst(burst);

% Configure beamforming weights
W = fft(eye(ntxants)) / sqrt(ntxants);

% Beamform the OFDM symbols corresponding to each burst
beamformedGrid = zeros([size(burstGrid) ntxants]);
blockSubcarriers = burstInfo.OccupiedSubcarriers;
for ssb = 1:length(burstInfo.SSBIndex)

    blockSymbols = burstInfo.OccupiedSymbols(ssb,:);
    block = burstGrid(blockSubcarriers,blockSymbols);
    Wssb = W(mod(ssb-1,ntxants)+1,:);
    beamformedBlock = reshape(block(:) * Wssb,[size(block) ntxants]);
    beamformedGrid(blockSubcarriers,blockSymbols,:) = beamformedBlock;

end

% Perform OFDM modulation
beamformedGrid = beamformedGrid(:,1:max(burstInfo.OccupiedSymbols(:))+1,:);
ofdmConfig.SubcarrierSpacing = burstInfo.SubcarrierSpacing;
ofdmConfig.NRB = burstInfo.NRB;
ofdmConfig.CyclicPrefix = burstInfo.CyclicPrefix;
ofdmConfig.Windowing = 0;
[burstWaveform,ofdmInfo] = hOFDMModulate(ofdmConfig,beamformedGrid);

rxWaveform = channel(burstWaveform);

rng('default');
rxWaveform = awgn(rxWaveform,SNRdB,-10*log10(double(ofdmInfo.Nfft)));

pssIndices = nrPSSIndices;
pssGrid = zeros([240 4]);
refGrid = zeros([ofdmInfo.NSubcarriers ofdmInfo.SymbolsPerSlot]);
k = burstInfo.OccupiedSubcarriers;
l = burstInfo.OccupiedSymbols(1,:);

figure;
hold on;
peak_value = zeros(1,3);
peak_index = zeros(1,3);
for NID2 = [0 1 2]

    pssRef = nrPSS(NID2);
    pssGrid(pssIndices) = pssRef;
    refGrid(k,l) = pssGrid;
    refWaveform = hOFDMModulate(ofdmConfig,refGrid);
    refWaveform = refWaveform(refWaveform~=0);

    corr = zeros(size(rxWaveform));
    for r = 1:size(rxWaveform,2)
        antcorr = xcorr(rxWaveform(:,r),refWaveform);
        corr(:,r) = antcorr(size(rxWaveform,1):end);
    end
    corr = sum(abs(corr),2);
    [peak_value(NID2+1),peak_index(NID2+1)] = max(corr);
    plot(corr);

end

% Plot PSS correlations
axis([1 length(rxWaveform(:,1)) 0 max(peak_value)*1.1]);
title('PSS Correlations (time domain)');
ylabel('Magnitude');
xlabel('Sample Index');

% Determine NID2 by finding the strongest correlation
NID2 = find(peak_value==max(peak_value)) - 1;

% Determine timing offset
offset = peak_index(NID2+1) - 1;

% Plot selected NID2
plot(offset+1,peak_value(NID2+1),'kx','LineWidth',2,'MarkerSize',8);
lgd = legend;
lgd.Interpreter = 'latex';
legends = "$N_{ID}^{(2)}$ = " + num2cell(0:2);
legend([legends "$N_{ID}^{(2)}$ = " + num2str(NID2)]);

% Extract strongest burst
offset = offset - ofdmInfo.SymbolLengths(1);
rxGrid = hOFDMDemodulate(ofdmConfig,rxWaveform(1+offset:end,:));
rxGrid = rxGrid(burstInfo.OccupiedSubcarriers,2:5,:);

% Extract the received SSS symbols from the SS/PBCH block
sssIndices = nrSSSIndices;
sssRx = nrExtractResources(sssIndices,rxGrid);

% Correlate received SSS symbols with each possible SSS sequence
sssEst = zeros(1,336);
for NID1 = 0:335

    ncellid = (3*NID1) + NID2;
    sssRef = nrSSS(ncellid);
    sssEst(NID1+1) = sum(abs(mean(sssRx .* conj(sssRef),1)).^2);

end

% Plot SSS correlations
figure;
stem(0:335,sssEst,'o');
title('SSS Correlations (frequency domain)');
xlabel('$N_{ID}^{(1)}$','Interpreter','latex');
ylabel('Magnitude');
axis([-1 336 0 max(sssEst)*1.1]);

% Determine NID1 by finding the strongest correlation
NID1 = find(sssEst==max(sssEst)) - 1;

% Plot selected NID1
hold on;
plot(NID1,max(sssEst),'kx','LineWidth',2,'MarkerSize',8);
lgd = legend;
lgd.Interpreter = 'latex';
legend(["correlations" "$N_{ID}^{(1)}$ = " + num2str(NID1)]);

% Form overall cell identity from NID1 and NID2
ncellid = (3*NID1) + NID2;

% Extract the received PBCH DM-RS symbols from the SS/PBCH block
dmrsIndices = nrPBCHDMRSIndices(ncellid);
[dmrsRx,dmrsRxIndices] = nrExtractResources(dmrsIndices,rxGrid);

% Correlate received DM-RS symbols with each possible DM-RS sequence
dmrsEst = zeros(1,8);
for ibar_SSB = 0:7

    dmrsRef = nrPBCHDMRS(ncellid,ibar_SSB);
    dmrsEst(ibar_SSB+1) = sum(abs(mean(dmrsRx .* conj(dmrsRef),1)).^2);

end

% Plot PBCH DM-RS correlations
figure;
stem(0:7,dmrsEst,'o');
title('PBCH DM-RS Correlations (frequency domain)');
xlabel('$\overline{i}_{SSB}$','Interpreter','latex');
xticks(0:7);
ylabel('Magnitude');
axis([-1 8 0 max(dmrsEst)*1.1]);

% Record ibar_SSB for the strongest correlation
ibar_SSB = find(dmrsEst==max(dmrsEst)) - 1;

% Plot selected ibar_SSB
hold on;
plot(ibar_SSB,max(dmrsEst),'kx','LineWidth',2,'MarkerSize',8);
lgd = legend;
lgd.Interpreter = 'latex';
legend(["correlations" "$\overline{i}_{SSB}$ = " + num2str(ibar_SSB)]);

% Channel estimation, using linear interpolation of the PBCH DM-RS
dmrsRef = nrPBCHDMRS(ncellid,ibar_SSB);
dmrsSubs = double(nrPBCHDMRSIndices(ncellid,'IndexStyle','subscript'));
hest = zeros([240 4 nrxants 1]);
[l_hest,k_hest] = meshgrid(1:size(hest,2),1:size(hest,1));
dmrsEsts = dmrsRx .* conj(dmrsRef);
for r = 1:nrxants
    f = scatteredInterpolant(dmrsSubs(:,2),dmrsSubs(:,1),dmrsEsts(:,r));
    hest(:,:,r) = f(l_hest,k_hest);
end

% Noise estimation, based on the difference between the PBCH DM-RS in
% symbols 2 and 4 (1-based) of the SS/PBCH block. This technique assumes
% that the channel itself does not change between the two symbols
dmrsEstsSym2 = dmrsEsts(dmrsSubs(:,2)==2,:);
dmrsEstsSym4 = dmrsEsts(dmrsSubs(:,2)==4,:);
dmrsEstsSym2and4 = [dmrsEstsSym2(:) dmrsEstsSym4(:)];
dmrsNoise = mean(dmrsEstsSym2and4,2) - dmrsEstsSym2and4;
nest = var(dmrsNoise(:)) * 2;

% Extract the received PBCH symbols from the SS/PBCH block
[pbchIndices,pbchIndicesInfo] = nrPBCHIndices(ncellid);
pbchRx = nrExtractResources(pbchIndices,rxGrid);

% Plot received PBCH constellation before equalization
figure;
plot(pbchRx,'o');
title('Received PBCH constellation');
m = max(abs([real(pbchRx(:)); imag(pbchRx(:))])) * 1.1;
axis([-m m -m m]);

% Configure 'v' for PBCH scrambling according to TS 38.211 Section 7.3.3.1
% 'v' is also the 2 LSBs of the SS/PBCH block index for L=4, or the 3 LSBs
% for L=8 or 64
if (burstInfo.L==4)
    v = mod(ibar_SSB,4);
else
    v = ibar_SSB;
end
ssbIndex = v;

% PBCH equalization and CSI calculation
pbchHest = nrExtractResources(pbchIndices,hest);
[pbchEq,csi] = nrEqualizeMMSE(pbchRx,pbchHest,nest);
Qm = pbchIndicesInfo.G / pbchIndicesInfo.Gd;
csi = repmat(csi.',Qm,1);
csi = reshape(csi,[],1);

% Plot received PBCH constellation after equalization
figure;
plot(pbchEq,'o');
title('Equalized PBCH constellation');
m = max(abs([real(pbchEq(:)); imag(pbchEq(:))])) * 1.1;
axis([-m m -m m]);

% PBCH demodulation
pbchBits = nrPBCHDecode(pbchEq,ncellid,v,nest);

% Calculate RMS PBCH EVM
pbchRef = nrPBCH(pbchBits<0,ncellid,v);
evm = comm.EVM;
evm_rms = evm(pbchEq,pbchRef);

% Display calculated EVM
disp(['RMS PBCH EVM = ' num2str(evm_rms,'%0.3f') '%']);

% Apply CSI
pbchBits = pbchBits .* csi;

% Perform BCH decoding including rate recovery, polar decoding and CRC
% decoding. PBCH descrambling and separation of the BCH transport block
% bits 'trblk' from 8 additional payload bits A...A+7 is also performed:
%   A ... A+3: 4 LSBs of System Frame Number
%         A+4: half frame number
% A+5 ... A+7: for L=64, 3 MSBs of the SS/PBCH block index
%              for L=4 or 8, A+5 is the MSB of the subcarrier offset k_SSB
polarListLength = 8;
[~,err,trblk,sfn4lsb,nHalfFrame,msbidxoffset] = ...
    nrBCHDecode(pbchBits,polarListLength,burstInfo.L,ncellid);

% Use 'msbidxoffset' value to set bits of 'k_SSB' or 'ssbIndex', depending
% on the number of SS/PBCH blocks in the burst
if (burstInfo.L==64)
    ssbIndex = ssbIndex + (bi2de(msbidxoffset.','left-msb') * 8);
    k_SSB = 0;
else
    k_SSB = msbidxoffset * 16;
end

% Display the BCH CRC
disp(['BCH CRC = ' num2str(err)]);

% Displaying the SSB index
disp(['SSB index = ' num2str(ssbIndex)]);

% Create set of subcarrier spacings signaled by the 7th bit of the decoded
% MIB, the set is different for FR1 (L=4 or 8) and FR2 (L=64)
if (burstInfo.L==64)
    commonSCSs = [60 120];
else
    commonSCSs = [15 30];
end

% Create a structure of MIB fields from the decoded MIB bits. The BCH
% transport block 'trblk' is the RRC message BCCH-BCH-Message, consisting
% of a leading 0 bit then 23 bits corresponding to the MIB
mib.NFrame = bi2de([trblk(2:7); sfn4lsb] .','left-msb');
mib.SubcarrierSpacingCommon = commonSCSs(trblk(8) + 1);
mib.k_SSB = k_SSB + bi2de(trblk(9:12).','left-msb');
mib.DMRSTypeAPosition = 2 + trblk(13);
mib.PDCCHConfigSIB1 = bi2de(trblk(14:21).','left-msb');
mib.CellBarred = trblk(22);
mib.IntraFreqReselection = trblk(23);

% Display the MIB structure
disp(mib);