cell search, mib and sib1 recovery -凯发k8网页登录

loadfromfile = 1; % set to 0 to generate the enodeb output locally

if loadfromfile
    load enodeboutput.mat           % load i/q capture of enodeb output
    enodeboutput = double(enodeboutput)/32768; % scale samples
    sr = 15.36e6;                   % sampling rate for loaded samples
else
    rmc = ltermcdl('r.3'); %#ok
    rmc.ncellid = 17;
    rmc.totsubframes = 41;
    rmc.pdsch.rnti = 61;
    % sib parameters
    rmc.sib.enable = 'on';
    rmc.sib.dciformat = 'format1a';
    rmc.sib.allocationtype = 0;
    rmc.sib.vrbstart = 8;
    rmc.sib.vrblength = 8;
    rmc.sib.gap = 0;
    % sib data field filled with random bits, this is not a valid sib
    % message
    rmc.sib.data = randi([0 1],176,1);
    [enodeboutput,~,info] = ltermcdltool(rmc,[1;0;0;1]);
    sr = info.samplingrate;     % sampling rate of generated samples
end

% set up some housekeeping variables:
% separator for command window logging
separator = repmat('-',1,50);
% plots
if (~exist('channelfigure','var') || ~isvalid(channelfigure))
    channelfigure = figure('visible','off');
end
[spectrumscope,synchcorrplot,pdcchconstdiagram] = ...
    hsib1recoveryexampleplots(channelfigure,sr);
% pdsch evm
pdschevm = comm.evm();
pdschevm.maximumevmoutputport = true;
% the sampling rate for the initial cell search is established using
% lteofdminfo configured for 6 resource blocks. enb.cyclicprefix is set
% temporarily in the call to lteofdminfo to suppress a default value
% warning (it does not affect the sampling rate).
enb = struct;                   % enodeb config structure
enb.ndlrb = 6;                  % number of resource blocks
ofdminfo = lteofdminfo(setfield(enb,'cyclicprefix','normal')); %#ok
if (isempty(enodeboutput))
    fprintf('\nreceived signal must not be empty.\n');
    return;
end
% display received signal spectrum
fprintf('\nplotting received signal spectrum...\n');
spectrumscope(awgn(enodeboutput, 100.0));
if (sr~=ofdminfo.samplingrate)
    if (sr < ofdminfo.samplingrate)
        warning('the received signal sampling rate (%0.3fms/s) is lower than the desired sampling rate for cell search / mib decoding (%0.3fms/s); cell search / mib decoding may fail.',sr/1e6,ofdminfo.samplingrate/1e6);
    end
    fprintf('\nresampling from %0.3fms/s to %0.3fms/s for cell search / mib decoding...\n',sr/1e6,ofdminfo.samplingrate/1e6);
else
    fprintf('\nresampling not required; received signal is at desired sampling rate for cell search / mib decoding (%0.3fms/s).\n',sr/1e6);
end
% downsample received signal
nsamples = ceil(ofdminfo.samplingrate/round(sr)*size(enodeboutput,1));
nrxants = size(enodeboutput, 2);
downsampled = zeros(nsamples, nrxants);
for i=1:nrxants
    downsampled(:,i) = resample(enodeboutput(:,i), ofdminfo.samplingrate, round(sr));
end

fprintf('\nperforming cell search...\n');
% set up duplex mode and cyclic prefix length combinations for search; if
% either of these parameters is configured in |enb| then the value is
% assumed to be correct
if (~isfield(enb,'duplexmode'))
    duplexmodes = {'tdd' 'fdd'};
else
    duplexmodes = {enb.duplexmode};
end
if (~isfield(enb,'cyclicprefix'))
    cyclicprefixes = {'normal' 'extended'};
else
    cyclicprefixes = {enb.cyclicprefix};
end
% perform cell search across duplex mode and cyclic prefix length
% combinations and record the combination with the maximum correlation; if
% multiple cell search is configured, this example will decode the first
% (strongest) detected cell
searchalg.maxcellcount = 1;
searchalg.sssdetection = 'postfft';
peakmax = -inf;
for duplexmode = duplexmodes
    for cyclicprefix = cyclicprefixes
        enb.duplexmode = duplexmode{1};
        enb.cyclicprefix = cyclicprefix{1};
        [enb.ncellid, offset, peak] = ltecellsearch(enb, downsampled, searchalg);
        enb.ncellid = enb.ncellid(1);
        offset = offset(1);
        peak = peak(1);
        if (peak>peakmax)
            enbmax = enb;
            offsetmax = offset;
            peakmax = peak;
        end
    end
end
% use the cell identity, cyclic prefix length, duplex mode and timing
% offset which gave the maximum correlation during cell search
enb = enbmax;
offset = offsetmax;
% compute the correlation for each of the three possible primary cell
% identities; the peak of the correlation for the cell identity established
% above is compared with the peak of the correlation for the other two
% primary cell identities in order to establish the quality of the
% correlation.
corr = cell(1,3);
idgroup = floor(enbmax.ncellid/3);
for i = 0:2
    enb.ncellid = idgroup*3   mod(enbmax.ncellid   i,3);
    [~,corr{i 1}] = ltedlframeoffset(enb, downsampled);
    corr{i 1} = sum(corr{i 1},2);
end
threshold = 1.3 * max([corr{2}; corr{3}]); % multiplier of 1.3 empirically obtained
if (max(corr{1})'synchronization signal correlation was weak; detected cell identity may be incorrect.');
end
% return to originally detected cell identity
enb.ncellid = enbmax.ncellid;
% plot pss/sss correlation and threshold
synchcorrplot.ylimits = [0 max([corr{1}; threshold])*1.1];
synchcorrplot([corr{1} threshold*ones(size(corr{1}))]);
% perform timing synchronization
fprintf('timing offset to frame start: %d samples\n',offset);
downsampled = downsampled(1 offset:end,:);
enb.nsubframe = 0;
% show cell-wide settings
fprintf('cell-wide settings after cell search:\n');
disp(enb);

fprintf('\nperforming frequency offset estimation...\n');
% for tdd, tddconfig and ssc are defaulted to 0. these parameters are not
% established in the system until sib1 is decoded, so at this stage the
% values of 0 make the most conservative assumption (fewest downlink
% subframes and shortest special subframe).
if (strcmpi(enb.duplexmode,'tdd'))
    enb.tddconfig = 0;
    enb.ssc = 0;
end
delta_f = ltefrequencyoffset(enb, downsampled);
fprintf('frequency offset: %0.3fhz\n',delta_f);
downsampled = ltefrequencycorrect(enb, downsampled, delta_f);

% channel estimator configuration
cec.pilotaverage = 'userdefined';     % type of pilot averaging
cec.freqwindow = 13;                  % frequency window size
cec.timewindow = 9;                   % time window size
cec.interptype = 'cubic';             % 2d interpolation type
cec.interpwindow = 'centered';        % interpolation window type
cec.interpwinsize = 1;                % interpolation window size
% assume 4 cell-specific reference signals for initial decoding attempt;
% ensures channel estimates are available for all cell-specific reference
% signals
enb.cellrefp = 4;
fprintf('performing ofdm demodulation...\n\n');
griddims = lteresourcegridsize(enb); % resource grid dimensions
l = griddims(2);                     % number of ofdm symbols in a subframe
% ofdm demodulate signal
rxgrid = lteofdmdemodulate(enb, downsampled);
if (isempty(rxgrid))
    fprintf('after timing synchronization, signal is shorter than one subframe so no further demodulation will be performed.\n');
    return;
end
% perform channel estimation
[hest, nest] = ltedlchannelestimate(enb, cec, rxgrid(:,1:l,:));

% decode the mib
% extract resource elements (res) corresponding to the pbch from the first
% subframe across all receive antennas and channel estimates
fprintf('performing mib decoding...\n');
pbchindices = ltepbchindices(enb);
[pbchrx, pbchhest] = lteextractresources( ...
    pbchindices, rxgrid(:,1:l,:), hest(:,1:l,:,:));
% decode pbch
[bchbits, pbchsymbols, nfmod4, mib, enb.cellrefp] = ltepbchdecode( ...
    enb, pbchrx, pbchhest, nest);
% parse mib bits
enb = ltemib(mib, enb);
% incorporate the nfmod4 value output from the function ltepbchdecode, as
% the nframe value established from the mib is the system frame number
% (sfn) modulo 4 (it is stored in the mib as floor(sfn/4))
enb.nframe = enb.nframe nfmod4;
% display cell wide settings after mib decoding
fprintf('cell-wide settings after mib decoding:\n');
disp(enb);
if (enb.cellrefp==0)
    fprintf('mib decoding failed (enb.cellrefp=0).\n\n');
    return;
end
if (enb.ndlrb==0)
    fprintf('mib decoding failed (enb.ndlrb=0).\n\n');
    return;
end

fprintf('restarting reception now that bandwidth (ndlrb=%d) is known...\n',enb.ndlrb);
% resample now we know the true bandwidth
ofdminfo = lteofdminfo(enb);
if (sr~=ofdminfo.samplingrate)
    if (sr < ofdminfo.samplingrate)
        warning('the received signal sampling rate (%0.3fms/s) is lower than the desired sampling rate for ndlrb=%d (%0.3fms/s); pdcch search / sib1 decoding may fail.',sr/1e6,enb.ndlrb,ofdminfo.samplingrate/1e6);
    end
    fprintf('\nresampling from %0.3fms/s to %0.3fms/s...\n',sr/1e6,ofdminfo.samplingrate/1e6);
else
    fprintf('\nresampling not required; received signal is at desired sampling rate for ndlrb=%d (%0.3fms/s).\n',enb.ndlrb,sr/1e6);
end
nsamples = ceil(ofdminfo.samplingrate/round(sr)*size(enodeboutput,1));
resampled = zeros(nsamples, nrxants);
for i = 1:nrxants
    resampled(:,i) = resample(enodeboutput(:,i), ofdminfo.samplingrate, round(sr));
end
% perform frequency offset estimation and correction
fprintf('\nperforming frequency offset estimation...\n');
delta_f = ltefrequencyoffset(enb, resampled);
fprintf('frequency offset: %0.3fhz\n',delta_f);
resampled = ltefrequencycorrect(enb, resampled, delta_f);
% find beginning of frame
fprintf('\nperforming timing offset estimation...\n');
offset = ltedlframeoffset(enb, resampled);
fprintf('timing offset to frame start: %d samples\n',offset);
% aligning signal with the start of the frame
resampled = resampled(1 offset:end,:);
% ofdm demodulation
fprintf('\nperforming ofdm demodulation...\n\n');
rxgrid = lteofdmdemodulate(enb, resampled);

% check this frame contains sib1, if not advance by 1 frame provided we
% have enough data, terminate otherwise.
if (mod(enb.nframe,2)~=0)
    if (size(rxgrid,2)>=(l*10))
        rxgrid(:,1:(l*10),:) = [];
        fprintf('skipping frame %d (odd frame number does not contain sib1).\n\n',enb.nframe);
    else
        rxgrid = [];
    end
    enb.nframe = enb.nframe   1;
end
% advance to subframe 5, or terminate if we have less than 5 subframes
if (size(rxgrid,2)>=(l*5))
    rxgrid(:,1:(l*5),:) = [];   % remove subframes 0 to 4
else
    rxgrid = [];
end
enb.nsubframe = 5;
if (isempty(rxgrid))
    fprintf('received signal does not contain a subframe carrying sib1.\n\n');
end
% reset the harq buffers
decstate = [];
% while we have more data left, attempt to decode sib1
while (size(rxgrid,2) > 0)
    fprintf('%s\n',separator);
    fprintf('sib1 decoding for frame %d\n',mod(enb.nframe,1024));
    fprintf('%s\n\n',separator);
    % reset the harq buffer with each new set of 8 frames as the sib1
    % info may be different
    if (mod(enb.nframe,8)==0)
        fprintf('resetting harq buffers.\n\n');
        decstate = [];
    end
    % extract current subframe
    rxsubframe = rxgrid(:,1:l,:);
    % perform channel estimation
    [hest,nest] = ltedlchannelestimate(enb, cec, rxsubframe);
    % pcfich demodulation, cfi decoding. the cfi is now demodulated and
    % decoded using similar resource extraction and decode functions to
    % those shown already for bch reception. lteextractresources is used to
    % extract res corresponding to the pcfich from the received subframe
    % rxsubframe and channel estimate hest.
    fprintf('decoding cfi...\n\n');
    pcfichindices = ltepcfichindices(enb);  % get pcfich indices
    [pcfichrx, pcfichhest] = lteextractresources(pcfichindices, rxsubframe, hest);
    % decode pcfich
    cfibits = ltepcfichdecode(enb, pcfichrx, pcfichhest, nest);
    cfi = ltecfidecode(cfibits); % get cfi
    if (isfield(enb,'cfi') && cfi~=enb.cfi)
        release(pdcchconstdiagram);
    end
    enb.cfi = cfi;
    fprintf('decoded cfi value: %d\n\n', enb.cfi);
    % for tdd, the pdcch must be decoded blindly across possible values of
    % the phich configuration factor m_i (0,1,2) in ts36.211 table 6.9-1.
    % values of m_i = 0, 1 and 2 can be achieved by configuring tdd
    % uplink-downlink configurations 1, 6 and 0 respectively.
    if (strcmpi(enb.duplexmode,'tdd'))
        tddconfigs = [1 6 0];
    else
        tddconfigs = 0; % not used for fdd, only used to control while loop
    end
    alldci = {};
    while (isempty(alldci) && ~isempty(tddconfigs))
        % configure tdd uplink-downlink configuration
        if (strcmpi(enb.duplexmode,'tdd'))
            enb.tddconfig = tddconfigs(1);
        end
        tddconfigs(1) = [];
        % pdcch demodulation. the pdcch is now demodulated and decoded
        % using similar resource extraction and decode functions to those
        % shown already for bch and cfi reception
        pdcchindices = ltepdcchindices(enb); % get pdcch indices
        [pdcchrx, pdcchhest] = lteextractresources(pdcchindices, rxsubframe, hest);
        % decode pdcch and plot constellation
        [dcibits, pdcchsymbols] = ltepdcchdecode(enb, pdcchrx, pdcchhest, nest);
        pdcchconstdiagram(pdcchsymbols);
        % pdcch blind search for system information (si) and dci decoding.
        % the lte toolbox provides full blind search of the pdcch to find
        % any dci messages with a specified rnti, in this case the si-rnti.
        fprintf('pdcch search for si-rnti...\n\n');
        pdcch = struct('rnti', 65535);
        pdcch.controlchanneltype = 'pdcch';
        pdcch.enablecarrierindication = 'off';
        pdcch.searchspace = 'common';
        pdcch.enablemultiplecsirequest = 'off';
        pdcch.enablesrsrequest = 'off';
        pdcch.ntxants = 1;
        alldci = ltepdcchsearch(enb, pdcch, dcibits); % search pdcch for dci
    end
    % if dci was decoded, proceed with decoding pdsch / dl-sch
    for i = 1:numel(alldci)
        dci = alldci{i};
        fprintf('dci message with si-rnti:\n');
        disp(dci);
        % get the pdsch configuration from the dci
        [pdsch, trblklen] = hpdschconfiguration(enb, dci, pdcch.rnti);
        % if a pdsch configuration was created, proceed with decoding pdsch
        % / dl-sch
        if ~isempty(pdsch)
            pdsch.nturbodecits = 5;
            fprintf('pdsch settings after dci decoding:\n');
            disp(pdsch);
            % pdsch demodulation and dl-sch decoding to recover sib bits.
            % the dci message is now parsed to give the configuration of
            % the corresponding pdsch carrying sib1, the pdsch is
            % demodulated and finally the received bits are dl-sch decoded
            % to yield the sib1 bits.
            fprintf('decoding sib1...\n\n');
            % get pdsch indices
            [pdschindices,pdschindicesinfo] = ltepdschindices(enb, pdsch, pdsch.prbset);
            [pdschrx, pdschhest] = lteextractresources(pdschindices, rxsubframe, hest);
            % decode pdsch
            [dlschbits,pdschsymbols] = ltepdschdecode(enb, pdsch, pdschrx, pdschhest, nest);
            % decode dl-sch with soft buffer input/output for harq combining
            if ~isempty(decstate)
                fprintf('recombining with previous transmission.\n\n');
            end
            [sib1, crc, decstate] = ltedlschdecode(enb, pdsch, trblklen, dlschbits, decstate);
            % compute pdsch evm
            recoded = ltedlsch(enb, pdsch, pdschindicesinfo.g, sib1);
            remod = ltepdsch(enb, pdsch, recoded);
            [~,refsymbols] = ltepdschdecode(enb, pdsch, remod);
            [rmsevm,peakevm] = pdschevm(refsymbols{1}, pdschsymbols{1});
            fprintf('pdsch rms evm: %0.3f%%\n',rmsevm);
            fprintf('pdsch peak evm: %0.3f%%\n\n',peakevm);
            fprintf('sib1 crc: %d\n',crc);
            if crc == 0
                fprintf('successful sib1 recovery.\n\n');
            else
                fprintf('sib1 decoding failed.\n\n');
            end
        else
            % indicate that creating a pdsch configuration from the dci
            % message failed
            fprintf('creating pdsch configuration from dci message failed.\n\n');
        end
    end
    if (numel(alldci)==0)
        % indicate that dci decoding failed
        fprintf('dci decoding failed.\n\n');
    end
    % update channel estimate plot
    figure(channelfigure);
    surf(abs(hest(:,:,1,1)));
    hsib1recoveryexampleplots(channelfigure);
    channelfigure.currentaxes.xlim = [0 size(hest,2) 1];
    channelfigure.currentaxes.ylim = [0 size(hest,1) 1];
    % skip 2 frames and try sib1 decoding again, or terminate if we
    % have less than 2 frames left.
    if (size(rxgrid,2)>=(l*20))
        rxgrid(:,1:(l*20),:) = [];   % remove 2 more frames
    else
        rxgrid = []; % less than 2 frames left
    end
    enb.nframe = mod(enb.nframe   2,1024);
end