% Check that LTE Toolbox is installed, and that there is a valid license
if isempty(ver('lte')) % Check for LST install
    error('zynqRadioLTEReceiver:NoLST','Please install LTE Toolbox to run this example.');
elseif ~license('test', 'LTE_Toolbox') % Check that a valid license is present
    error('zynqRadioLTEReceiver:NoLST','A valid license for LTE Toolbox is required to run this example.');
end

% User defined parameters
rxsim.RadioFrontEndSampleRate = 1.92e6; % Configured for 1.92 MHz capture bandwidth
rxsim.RadioCenterFrequency = 2.45e9;
rxsim.RadioChannelMapping = 1;
rxsim.FramesPerCapture = 5;   % Number of contiguous LTE frames to capture
rxsim.numCaptures = 1; % Number of captures

% Derived parameters
samplesPerFrame = 10e-3*rxsim.RadioFrontEndSampleRate; % LTE frames period is 10 ms

captureTime = rxsim.FramesPerCapture * 10e-3; % LTE frames period is 10 ms

rxsim.SDRDeviceName = 'AD936x';
% To update the example for FMCOMMS5, set |rxsim.SDRDeviceName| to
% |'FMCOMMS5'|.
radio = sdrdev(rxsim.SDRDeviceName);

sdrReceiver = sdrrx( ...
    rxsim.SDRDeviceName, ...
    'IPAddress',              '192.168.3.2', ...
    'BasebandSampleRate',     rxsim.RadioFrontEndSampleRate, ...
    'CenterFrequency',        rxsim.RadioCenterFrequency, ...
    'ChannelMapping',         rxsim.RadioChannelMapping, ...
    'OutputDataType',         'double', ...
    'GainSource',             'AGC Fast Attack', ...
    'ShowAdvancedProperties', true, ...
    'BypassUserLogic',        true);

% Spectrum viewer setup
spectrumScope = dsp.SpectrumAnalyzer( ...
    'SampleRate',      rxsim.RadioFrontEndSampleRate, ...
    'SpectrumType',    'Power density', ...
    'SpectralAverages', 10, ...
    'YLimits',         [-130 -20], ...
    'Title',           'Baseband LTE Signal Spectrum', ...
    'YLabel',          'Power spectral density');

enb.DuplexMode = 'FDD';
enb.CyclicPrefix = 'Normal';
enb.CellRefP = 4;

% Bandwidth: {1.4 MHz, 3 MHz, 5 MHz, 10 MHz, 20 MHz}
SampleRateLUT = [1.92 3.84 7.68 15.36 30.72]*1e6;
NDLRBLUT = [6 15 25 50 100];
enb.NDLRB = NDLRBLUT(SampleRateLUT==rxsim.RadioFrontEndSampleRate);
if isempty(enb.NDLRB)
    error('Sampling rate not supported. Supported rates are %s.',...
            '1.92 MHz, 3.84 MHz, 7.68 MHz, 15.36 MHz, 30.72 MHz');
end
fprintf('\nSDR hardware sampling rate configured to capture %d LTE RBs.\n',enb.NDLRB);

cec.FreqWindow = 9;               % Frequency averaging window in Resource Elements (REs)
cec.TimeWindow = 9;               % Time averaging window in REs
cec.InterpType = 'Cubic';         % Cubic interpolation
cec.PilotAverage = 'UserDefined'; % Pilot averaging method
cec.InterpWindow = 'Centred';     % Interpolation windowing method
cec.InterpWinSize = 3;            % Interpolate up to 3 subframes simultaneously

% Setup the constellation diagram viewer for equalized PDCCH symbols
constellation = comm.ConstellationDiagram('Title','Equalized PDCCH Symbols') ;

% Handle for channel estimate plots
channelEstimatePlot = figure('Visible','Off');

enbDefault = enb;

while rxsim.numCaptures
    % Set default LTE parameters
    enb = enbDefault;

    % SDR Capture
    fprintf('\nStarting a new RF capture.\n')

    % rxWaveform holds |rxsim.FramesPerCapture| number of consecutive frames worth
    % of contiguous baseband LTE samples.
    rxWaveform = capture(sdrReceiver, captureTime, 'Seconds');

    % Show power spectral density of captured burst
    spectrumScope(rxWaveform);

    % Perform frequency offset correction
    frequencyOffset = lteFrequencyOffset(enb,rxWaveform);
    rxWaveform = lteFrequencyCorrect(enb,rxWaveform,frequencyOffset);
    fprintf('Corrected a frequency offset of %g Hz.\n',frequencyOffset)

    % Perform the blind cell search to obtain cell identity and timing offset
    %   Use 'PostFFT' SSS detection method to improve speed
    cellSearch.SSSDetection = 'PostFFT'; cellSearch.MaxCellCount = 1;
    [NCellID,frameOffset] = lteCellSearch(enb,rxWaveform,cellSearch);
    fprintf('Detected a cell identity of %i.\n', NCellID);
    enb.NCellID = NCellID; % From lteCellSearch

    % Sync the captured samples to the start of an LTE frame, and trim off
    % any samples that are part of an incomplete frame.
    rxWaveform = rxWaveform(frameOffset+1:end);
    tailSamples = mod(length(rxWaveform),samplesPerFrame);
    rxWaveform = rxWaveform(1:end-tailSamples);
    enb.NSubframe = 0;

    % OFDM demodulation
    rxGrid = lteOFDMDemodulate(enb,rxWaveform);

    % Perform channel estimation for 4 CellRefP as currently we do not
    % know the CellRefP for the eNodeB.
    [hest,nest] = lteDLChannelEstimate(enb,cec,rxGrid);

    sfDims = lteResourceGridSize(enb);
    Lsf = sfDims(2); % OFDM symbols per subframe
    LFrame = 10*Lsf; % OFDM symbols per frame
    numFullFrames = length(rxWaveform)/samplesPerFrame;

    % For each frame decode the MIB and CFI
    for frame = 0:(numFullFrames-1)
        fprintf('\nPerforming MIB Decode for frame %i of %i in burst...\n', ...
            frame+1,numFullFrames)

        % Extract subframe #0 from each frame of the received resource grid
        % and channel estimate.
        enb.NSubframe = 0;
        rxsf = rxGrid(:,frame*LFrame+(1:Lsf));
        hestsf = hest(:,frame*LFrame+(1:Lsf),:,:);

        % PBCH demodulation. Extract resource elements (REs)
        % corresponding to the PBCH from the received grid and channel
        % estimate grid for demodulation. Assume 4 cell-specific reference
        % signals for PBCH decode as initially we do not know actual value.
        enb.CellRefP = 4;
        pbchIndices = ltePBCHIndices(enb);
        [pbchRx,pbchHest] = lteExtractResources(pbchIndices,rxsf,hestsf);
        [~,~,nfmod4,mib,CellRefP] = ltePBCHDecode(enb,pbchRx,pbchHest,nest);

        % If PBCH decoding successful CellRefP~=0 then update info
        if ~CellRefP
            fprintf('  No PBCH detected for frame.\n');
            continue;
        end

        % With successful PBCH decoding, decode the MIB and obtain system
        % information including system bandwidth
        enb = lteMIB(mib,enb);
        enb.CellRefP = CellRefP; % From ltePBCHDecode
        % Incorporate the nfmod4 value output from the function
        % ltePBCHDecode, as the NFrame value established from the MIB
        % is the system frame number modulo 4.
        enb.NFrame = enb.NFrame+nfmod4;
        fprintf('  Successful MIB Decode.\n')
        fprintf('  Frame number: %d.\n',enb.NFrame);

        % The eNodeB transmission bandwidth may be greater than the
        % captured bandwidth, so limit the bandwidth for processing
        enb.NDLRB = min(enbDefault.NDLRB,enb.NDLRB);

        % Process subframes within frame
        for sf = 0:9
            % Extract subframe
            enb.NSubframe = sf;
            rxsf = rxGrid(:,frame*LFrame+sf*Lsf+(1:Lsf));

            % Perform channel estimation with the correct number of CellRefP
            [hestsf,nestsf] = lteDLChannelEstimate(enb,cec,rxsf);

            % PCFICH demodulation. Extract REs corresponding to the PCFICH
            % from the received grid and channel estimate for demodulation.
            pcfichIndices = ltePCFICHIndices(enb);
            [pcfichRx,pcfichHest] = lteExtractResources(pcfichIndices,rxsf,hestsf);
            [cfiBits,recsym] = ltePCFICHDecode(enb,pcfichRx,pcfichHest,nestsf);

            % CFI decoding
            enb.CFI = lteCFIDecode(cfiBits);
            fprintf('    Subframe %d, decoded CFI value: %d.\n',sf,enb.CFI);

            % PDCCH demodulation. Extract REs corresponding to the PDCCH
            % from the received grid and channel estimate for demodulation.
            pdcchIndices = ltePDCCHIndices(enb);
            [pdcchRx,pdcchHest] = lteExtractResources(pdcchIndices,rxsf,hestsf);
            [pdcchBits,pdcchEq] = ltePDCCHDecode(enb,pdcchRx,pdcchHest,nestsf);
            release(constellation);
            constellation(pdcchEq);
            pause(0); % Allow constellation to repaint
        end

        % Plot channel estimate between CellRefP 0 and the receive antenna
        focalFrameIdx = frame*LFrame+(1:LFrame);
        set(0,'CurrentFigure',channelEstimatePlot);
        channelEstimatePlot.Visible = 'On';
        surf(abs(hest(:,focalFrameIdx,1,1)));
        xlabel('OFDM symbol index');
        ylabel('Subcarrier index');
        zlabel('Magnitude');
        title('Estimate of Channel Magnitude Frequency Repsonse');
    end
    rxsim.numCaptures = rxsim.numCaptures-1;
end
release(sdrReceiver); % Release SDR receiver object
release(spectrumScope);  % Release spectrum analyzer object
release(constellation);  % Release constellation diagram object