ue detection using downlink signals -凯发k8网页登录

load uedetectionwaveform.mat;
rxwaveform = double(rxwaveform) / 32768;

% perform frequency offset estimation and correction
foffset = ltefrequencyoffset(enb,rxwaveform);
rxwaveform = ltefrequencycorrect(enb,rxwaveform,foffset);
% perform timing synchronization to the first whole subframe of the
% waveform
toffset = ltedlframeoffset(enb,rxwaveform);
ofdminfo = lteofdminfo(enb);
sflength = ofdminfo.samplingrate * 1e-3;
offsetsubframes = floor(toffset / sflength);
toffset = toffset - (offsetsubframes * sflength);
rxwaveform = rxwaveform(1 toffset:end,:);
enb.nsubframe = mod(-offsetsubframes,10);

rxgrid = lteofdmdemodulate(enb,rxwaveform);

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

% maximum number of bit errors allowed to consider a detection as valid
maxerrors = 2;
% minimum pdcch power in db (relative to the cell-specific reference signal
% used for channel estimation) to consider a detection as valid
minpdcchpower = -5.0;
% initialize results table
results = table;
% get dci formats and lengths for dci messages in the common search space
pdcchcommon = struct('searchspace','common');
pdcchcommon.controlchanneltype = 'pdcch';
cif = 'off'; % enable or disable carrier indicator field
pdcchcommon.enablecarrierindication = cif;
[dciinfocommon,pdcchcommon] = getuniquedcilengths(enb,pdcchcommon);
% get dci formats and lengths for dci messages in the ue-specific search
% space. the length of a dci message of a given format may be affected by
% various ue-specific higher-layer parameters so the set of different
% unique lengths across those parameters is recorded, along with the
% corresponding parameter combinations
pdcchuespecific = struct('searchspace','uespecific');
pdcchuespecific.controlchanneltype = 'pdcch';
pdcchuespecific.enablecarrierindication = cif;
[dciinfouespecific,pdcchuespecific] = getuniquedcilengths(enb,pdcchuespecific);
% establish the number of subframes in the waveform
griddims = lteresourcegridsize(enb);
l = griddims(2);
nsubframes = floor(size(rxgrid,2) / l);
% for each subframe in the waveform, attempt to decode the pdcch
startsubframe = enb.nsubframe;
cfis = zeros(1,nsubframes);
for i = 0:nsubframes-1
    % extract the current subframe
    rxsubframe = rxgrid(:,(i*l)   (1:l),:);
    % perform channel estimation
    [hest,nest] = ltedlchannelestimate(enb,cec,rxsubframe);
    % if the current subframe contains the first occurrence of the mib in
    % the waveform, decode the mib to establish the frame number
    if (enb.nsubframe==0 && i<10)
        startframe = decodemib(enb,rxsubframe,hest,nest,i);
    end
    % get pcfich indices, extract received pcfich symbols and corresponding
    % channel estimate, demodulate pcfich, decode and record cfi
    pcfichindices = ltepcfichindices(enb);
    [pcfichrx,pcfichhest] = lteextractresources(pcfichindices,rxsubframe,hest);
    pcfichbits = ltepcfichdecode(enb,pcfichrx,pcfichhest,nest);
    enb.cfi = ltecfidecode(pcfichbits);
    cfis(i 1) = enb.cfi;
    % get pdcch indices
    pdcchindices = ltepdcchindices(enb);
    % extract received pdcch symbols and corresponding channel estimate
    [pdcchrx,pdcchhest] = lteextractresources(pdcchindices,rxsubframe,hest);
    % perform pdcch demodulation to obtain the received pdcch bits, which
    % may contain encoded dci messages for one or more users
    [pdcchbits,pdcchsymbols] = ltepdcchdecode(enb,pdcchrx,pdcchhest,nest);
    % initialize array of pdcch format / candidate / dci format
    % combinations, which represent possible ues (i.e. possible locations
    % for dci messages providing a downlink or uplink grant for a ue)
    possibleues = [];
    % pdcch format for ue-specific search space can be 0, 1, 2, or 3
    for pdcchformat = 0:3
        ue = struct();
        % get all pdcch candidate indices and the number of candidates m
        % for the current pdcch format
        ue.pdcchformat = pdcchformat;
        candidates = getpdcchcandidates(enb,ue);
        m = size(candidates,1);
        % for each candidate
        for m = 1:m
            % record pdcch candidate indices
            ue.candidate = candidates(m,:);
            % for each dci format in the ue-specific search space
            dciformats = fieldnames(dciinfouespecific);
            for dciformatidx = 1:length(dciformats)
                % record dci format
                ue.dciformat = dciformats{dciformatidx};
                % record this pdcch format / candidate / dci format
                % combination as a possible "ue". for dci formats that have
                % different lengths across the ue-specific higher-layer
                % parameters, each length is recorded as a different
                % possible ue
                dcilengths = dciinfouespecific.(ue.dciformat);
                for dcilengthidx = 1:length(dcilengths)
                    ue.dcilength = dcilengths(dcilengthidx);
                    ue.pdcch = pdcchuespecific.(ue.dciformat)(dcilengthidx);
                    possibleues = [possibleues ue]; %#ok
                end
            end
            % for pdcch formats 2 or 3, record the possibility of a dci
            % message in the common search space in this candidate location
            % with format 1a or 1c. such dci messages correspond to system
            % information, paging, or random access response message rather
            % than uplink or downlink grants for a ue, but are searched for
            % in this example for completeness
            if (any(pdcchformat==[2 3]))
                for dciformat = {'format1a' 'format1c'}
                    ue.dciformat = dciformat{1};
                    ue.dcilength = dciinfocommon.(ue.dciformat);
                    ue.pdcch = pdcchcommon.(ue.dciformat);
                    possibleues = [possibleues ue]; %#ok
                end
            end
        end
    end
    % for each possible ue
    for ue = possibleues
        % get the received candidate bits from the received pdcch bits (for
        % dci decoding)
        bitidx = ue.candidate;
        candidatebits = pdcchbits(bitidx(1):bitidx(2));
        % get the received candidate symbols from the received pdcch
        % symbols (for pdcch power estimation). the modulation order qm = 2
        % is used to convert candidate bit indices into candidate symbol
        % indices (qpsk modulation is always used for pdcch)
        qm = 2;
        symidx = [((bitidx(1) - 1) / qm)   1 bitidx(2)/qm];
        candidatesymbols = pdcchsymbols(symidx(1):symidx(2));
        % decode the received candidate bits and get the rnti. assuming a
        % crc pass (crc = 0), the 2nd output from ltedcidecode will
        % correspond to the rnti
        [dcimessagebits,rnti] = ltedcidecode(ue.dcilength,candidatebits);
        % re-encode the decoded dci message bits (using the detected rnti)
        % and establish the number of bit errors between the re-encoded
        % candidate bits and received candidate bits
        ue.rnti = rnti;
        reencodedcandidatebits = ltedciencode(ue,dcimessagebits);
        numerrors = sum(int8(candidatebits > 0) ~= reencodedcandidatebits);
        % if the number of bit errors is greater than maxerrors, continue
        % to the next possible ue (the rest of the loop body here is not
        % executed)
        if (numerrors > maxerrors)
            continue;
        end
        % create dci message structure from message bit payload. this is
        % performed because for some dci formats (e.g. format 0 versus
        % format 1a), the true dci format amongst dci formats with
        % the same length can be determined by the value of a message bit
        dci = ltedci(enb,ue.pdcch,dcimessagebits);
        % create table entry for the current dci message
        result = struct();
        result.subframe = i;
        result.detectedrnti = string(dec2hex(ue.rnti,4));
        result.numerrors = numerrors;
        result.dciformat = string(dci.dciformat);
        result.pdcchformat = ue.pdcchformat;
        result.candidate = ue.candidate;
        result.pdcchpower = round(10*log10(var(candidatesymbols)),2);
        result.dci = {dci};
        result = struct2table(result);
        % check if a dci message has previously been successfully decoded
        % in this subframe with the same rnti, dci format and starting
        % candidate location as the current dci message (but with a
        % different pdcch format)
        if (~isempty(results))
            match = (results.subframe == result.subframe);
            match = match & (results.detectedrnti == result.detectedrnti);
            match = match & strcmpi(results.dciformat,result.dciformat);
            match = match & (results.candidate(:,1) == result.candidate(1));
            match = find(match~=0);
        else
            match = [];
        end
        % if a dci message satisfies the criteria above, it must have been
        % for a smaller pdcch format and therefore represents successful
        % decoding of part of the current message, i.e. decoding a subset
        % of the candidate control channel elements (cces). therefore the
        % previous result can be replaced with the current result. note
        % that for larger pdcch formats the number of bit errors will tend
        % to be bigger as there are more candidate bits, so at low snrs the
        % detected pdcch format here may be lower than the true pdcch
        % format (i.e. the number of errors in the bits for the true pdcch
        % format exceeds maxerrors)
        if (isempty(match))
            results = [results; result]; %#ok
        else
            results(match,:) = result;
        end
    end
    % update the subframe number
    enb.nsubframe = mod(enb.nsubframe   1,10);
end
% remove results whose estimated pdcch power (in db) is lower than the
% minimum power threshold. without this step, received candidate symbols
% consisting solely of noise (even at a low power) can trigger false
% detections
if (~isempty(results))
    results(results.pdcchpower < minpdcchpower,:) = [];
end
% check if results are empty
if (isempty(results))
    disp('no rntis found.');
    return;
end
% in any given subframe, in the case of overlapping results (i.e. where the
% candidate indices of one result are a subset of another), the result with
% the lowest number of bit errors will be selected
overlapping = [];
for i = unique(results.subframe).'
    % find result rows which correspond to the current subframe and extract
    % those results
    sf = find(results.subframe == i).';
    % for each pair of results in this subframe
    for a = sf
        for b = sf
            ca = results{a,'candidate'};
            cb = results{b,'candidate'};
            % if the first result's candidate indices are a subset of the
            % second result's candidate indices
            if (ca(1)>=cb(1) && ca(2)<=cb(2))
                % if the first result has more errors
                if (results{a,'numerrors'}>results{b,'numerrors'})
                    % mark the first result in the pair as overlapping
                    % (i.e. mark it for removal)
                    overlapping = [overlapping a]; %#ok
                end
            end
        end
    end
end
% remove overlapping results
results(overlapping,:) = [];
% add a label for each row of the results table
results.properties.rownames = strsplit(num2str(1:height(results)));

disp(results);

enb.nframe = startframe;
enb.nsubframe = startsubframe;
enb.cfi = cfis;
summary = hplotdetectedrntis(results,enb,rxgrid);

disp(summary);

% get dci message information for dci formats with unique lengths, across
% all ue-specific higher-layer parameters
function [infoout,pdcchout] = getuniquedcilengths(enb,pdcchin)
    infoout = [];
    for enablesrsrequest = {'off' 'on'}
        pdcchin.enablesrsrequest = enablesrsrequest{1};
        for enablemultiplecsirequest = {'off' 'on'}
            pdcchin.enablemultiplecsirequest = enablemultiplecsirequest{1};
            for ntxants = [1 2 4]
                pdcchin.ntxants = ntxants;
                % get the dci message lengths for all formats, as a
                % structure
                info = ltedciinfo(enb,pdcchin);
                % convert the structure into a cell array of field names
                % and values
                formats = fieldnames(info);
                sizes = struct2cell(info);
                % remove dci format 3 and 3a as these dci formats are used
                % for conveying power control commands rather than resource
                % allocations
                dci3idx = ismember(formats,{'format3','format3a'});
                formats(dci3idx) = [];
                sizes(dci3idx) = [];
                % keep only dci format 1a and 1c for the common search
                % space
                if (strcmpi(pdcchin.searchspace,'common'))
                    commonidx = ismember(formats,{'format1a','format1c'});
                    formats = formats(commonidx);
                    sizes = sizes(commonidx);
                end
                % find the indices of the unique sizes, the first
                % occurrence of each unique size will be retained in the
                % original order
                [~,idxs] = unique(cat(2,sizes{:}),'stable');
                % if the current ue-specific settings yield unique sizes
                % for any format (compared to all other formats and
                % ue-specific settings thus far), then record them
                if (isempty(infoout))
                    infoout = cell2struct(sizes(idxs),formats(idxs));
                    pdcchout = cell2struct(repmat({pdcchin},size(idxs)),formats(idxs));
                else
                    sizes_out = struct2cell(infoout);
                    sizes_out = cat(2,sizes_out{:});
                    for i = idxs.'
                        if (~any(sizes_out==sizes{i}))
                            format = formats{i};
                            infoout.(format) = [infoout.(format) sizes{i}];
                            pdcchout.(format) = [pdcchout.(format) pdcchin];
                        end
                    end
                end
            end
        end
    end
end
% decode the mib to get the frame number
function startframe = decodemib(enb,rxsubframe,hest,nest,i)
    pbchindices = ltepbchindices(enb);
    [pbchrx, pbchhest] = lteextractresources(pbchindices,rxsubframe,hest);
    [~,~,nfmod4,mibbits] = ltepbchdecode(enb,pbchrx,pbchhest,nest);
    mib = ltemib(mibbits);
    startframe = double(mib.nframe)   nfmod4;
    if (i>0)
        startframe = mod(startframe - 1,1024);
    end
end
% get all pdcch candidates for a given enodeb configuration and ue
% configuration, without having to evaluate all possible rntis
function pdcchcandidates = getpdcchcandidates(enb,ue)
    % pdcch dimensionality information
    pdcchinfo = ltepdcchinfo(enb);
    % aggregation level
    l = 2 ^ ue.pdcchformat;
    % number of candidates
    m = floor(double(pdcchinfo.ncce)/l);
    % 1 cce = 9 regs = 36 res = 72 bits
    bitspercce = 72;
    % pdcch candidate indices within pdcch bits (1-based)
    pdcchcandidates = l*bitspercce*(0:m-1).'   [1 l*bitspercce];
end