End-to-End DVB-S2 Simulation with RF Impairments and Non-Pilot-Aided Corrections

Since R2024b

This example shows how to measure the bit error rate (BER) and packet error rate (PER) of a single stream Digital Video Broadcasting Satellite Second Generation (DVB-S2) link that has constant coding and a QPSK or 8-PSK modulation scheme. The example uses non-pilot-aided synchronization methods to estimate and compensate for RF front-end impairments under moderate-to-heavy noise conditions. The single stream signal adds RF front-end impairments and then passes the waveform through an additive white Gaussian noise (AWGN) channel.

For an example that exhibits pilot-aided synchronization, and supports APSK modulated frames in addition to QPSK and 8-PSK modulated frames, see End-to-End DVB-S2 Simulation with RF Impairments and Corrections

Introduction

DVB-S2 receivers are subjected to large carrier frequency errors and substantial phase noise. Few applications can be bandwidth intensive and at lower Es/No points, characteristics of the specific modulation schemes, such as QPSK, can be used to avoid inclusion of pilot fields within waveforms. The use of powerful forward error correction (FEC) mechanisms, such as Bose–Chaudhuri–Hocquenghem (BCH) and low density parity check (LDPC) codes, caused the DVB-S2 system to work at very low energy per symbol to noise power spectral density ratio (Es/No) values, close to the Shannon limit.

ETSI EN 302 307-1 Section 6 Table 13 [1] summarizes the Quasi-Error-Free (QEF) performance requirement over an AWGN channel for different modulation schemes and code rates. You can consider the operating Es/No range for different transmission modes as up to +3 dB from the Es/No point where you observe QEF performance. Because the operating Es/No range is low, carrier and symbol timing synchronization strategies are challenging design problems. The lower order modulation schemes supported by the DVB-S2 standard enable you to use the well-established general receiver synchronization algorithms required to design a low-complexity receiver, which you can use as a starting point for a receiver design.

This diagram summarizes the example procedure.

Main Processing Loop

The example processes 40 physical layer (PL) frames of data with the Es/No set to 12.5 dB, and then computes the BER and PER. Carrier frequency offset, sampling clock offset, and phase noise impairments are applied to the modulated signal, and AWGN is added to the signal.

At the receiver, after matched filtering, timing and carrier recovery operations are run to recover the transmitted data. To extract PL frames, the distorted waveform is processed through various timing and carrier recovery strategies. The carrier recovery algorithms are non-pilot-aided. To decode the data frames, the physical layer transmission parameters such as modulation scheme, code rate, and FEC frame type, are recovered from the PL header. To regenerate the input bit stream, the baseband (BB) header is decoded.

Because the DVB-S2 standard supports packetized and continuous modes of transmission, the BB frame can be either a concatenation of user packets or a stream of bits. The BB header is recovered to determine the mode of transmission. If the BB frame is a concatenation of user packets, the packet cyclic redundancy check (CRC) status of each packet is returned along with the decoded bits, and then the PER and BER are measured.

The following diagram shows the flow of the synchronization operations.

Post synchronization, the bit recovery from PL frames is carried out as follows.

Download DVB-S2 LDPC Parity Matrices Data Set

This example loads a MAT-file with DVB-S2 LDPC parity matrices. If the MAT-file is not available on the MATLAB® path, use these commands to download and unzip the MAT-file.

if exist("s2xLDPCParityMatrices","dir") && ~exist("dvbs2xLDPCParityMatrices.mat","file")
    addpath("s2xLDPCParityMatrices");
end
if ~exist("dvbs2xLDPCParityMatrices.mat","file")
    if ~exist("s2xLDPCParityMatrices.zip","file")
        url = "https://ssd.mathworks.com/supportfiles/spc/satcom/DVB/s2xLDPCParityMatrices.zip";
        websave("s2xLDPCParityMatrices.zip",url);
        unzip("s2xLDPCParityMatrices.zip");
    end
    addpath("s2xLDPCParityMatrices");
end

DVB-S2 Configuration in Non-Pilot-Aided Mode

Specify the cfgDVBS2 structure to define DVB-S2 transmission configuration parameters. The MODCOD value is in the range [1, 17], which implies the modulation scheme is either QPSK or 8-PSK. You can generate APSK waveforms, but this example does not support synchronization and corrections for APSK waveforms. UPL property is applicable when you set the StreamFormat to "GS".

cfgDVBS2.StreamFormat = "TS";
cfgDVBS2.FECFrame = "normal";
cfgDVBS2.MODCOD = 17;
cfgDVBS2.DFL = 58112;
cfgDVBS2.RolloffFactor = 0.35;
cfgDVBS2.HasPilots = false;
cfgDVBS2.SamplesPerSymbol = 2;

Simulation Parameters

The DVB-S2 standard supports flexible channel bandwidths. Use a typical channel bandwidth such as 36 MHz. The channel bandwidth can be varied. The coarse frequency synchronization algorithm implemented in this example can track carrier frequency offsets up to 8% of the input symbol rate, for higher Es/No values. For lower values of Es/No, the estimation algorithm might not yield the same level of estimation due to the non-pilot-aided configuration. The symbol rate is calculated as B/(1+R), where B is the channel bandwidth, and R is the transmit filter roll-off factor. The algorithms implemented in this example can correct the sampling clock offset up to 10 ppm.

simParams.sps = cfgDVBS2.SamplesPerSymbol;             % Samples per symbol
simParams.numFrames = 40;                              % Number of frames to be processed
simParams.chanBW = 36e6;                               % Channel bandwidth in Hertz
simParams.cfo = 20e5;                                  % Carrier frequency offset in Hertz
simParams.sco = 5;                                     % Sampling clock offset in parts
                                                       % per million
simParams.phNoiseLevel = "Low";         % Phase noise level provided as
                                                       % "Low", "Medium", or "High"
simParams.EsNodB = 12.5;                               % Energy per symbol to noise ratio

This table defines the phase noise mask (dBc/Hz) used to generate the phase noise applied to the transmitted signal.

Generate DVB-S2 Waveform Distorted with RF Impairments

To create a DVB-S2 waveform, use the HelperDVBS2RxInputGenerate helper function with the simParams and cfgDVBS2 structures as inputs. The function returns the data signal, transmitted and received waveforms, and a receiver processing structure. The received waveform is impaired with carrier frequency, timing phase offsets, and phase noise and then passed through an AWGN channel. The receiver processing parameters structure, rxParams, includes the reference pilot fields, pilot indices, counters, and buffers. Plot the constellation of the received symbols and the spectrum of the transmitted and received waveforms.

[data,txOut,rxIn,rxParams] = HelperDVBS2RxInputGenerate(cfgDVBS2,simParams);

% Received signal constellation plot
rxConst = comm.ConstellationDiagram(Title = "Received data", ...
    XLimits = [-1 1],YLimits = [-1 1], ...
    ShowReferenceConstellation = false, ...
    SamplesPerSymbol = simParams.sps);
rxConst(rxIn(1:length(txOut)))

% Transmitted and received signal spectrum visualization
Rsymb = simParams.chanBW/(1 + cfgDVBS2.RolloffFactor);
Fsamp = Rsymb*simParams.sps;
specAn = spectrumAnalyzer(SampleRate = Fsamp, ...
    ChannelNames = ["Transmitted waveform" "Received waveform"], ...
    ShowLegend = true);
specAn([txOut,rxIn(1:length(txOut))]);

Configure Receiver Parameters

At the receiver, symbol timing synchronization is performed on the received data and is then followed by frame synchronization. The receiver algorithms include coarse and fine frequency impairment correction algorithms. The carrier frequency estimation algorithm can track carrier frequency offsets up to 8% of the input symbol rate. The coarse frequency estimation, which uses an FFT-based frequency estimation algorithm, reduces the frequency offset to a level that the fine frequency estimator can track. The preferred loop bandwidth for symbol timing depends on the Es/No setting.

When you decrease Es/No, you can reduce the loop bandwidth to filter out more noise during acquisition. The number of frames required for the symbol synchronizer and coarse frequency estimate depends on the loop bandwidth setting. For weaker signals, set rxParams.symbSyncLoopBW = 1e-4 and set rxParams.symbSyncLock = ceil(1e5/rxParams.plFrameSize).

The frame synchronization uses the PL header. Es/No plays a crucial role in determining the accuracy of the frame synchronization. When QPSK modulated frames are being recovered at Es/No values below 3 dB, the frame synchronization must be performed on multiple frames for accurate detection.

The fine frequency estimation uses a closed-loop PLL to reduce the residual carrier frequency offset to levels acceptable for phase-ambiguity estimation. The phase-ambiguity estimation uses the start-of-frame symbols that have been received and processed to estimate the residual phase error, and the receiver performs a corrective phase rotation to remove the estimated phase error.

These settings are assigned in the rxParams structure for synchronization processing. For details on how to set these parameters for low Es/No values, see the Further Exploration section.

%% Configure receiver parameters
rxParams.carrSyncLoopBW = 1e-3;                          % Carrier synchronization normalized loop BW
rxParams.symbSyncLoopBW = 8e-3;                          % Symbol synchronization normalized loop BW
rxParams.symbSyncLock  =  ceil(1e5/rxParams.plFrameSize);% Number of frames for symbol timing error
                                                         % convergence
rxParams.coarseFreqResolution = 500;                     % Course frequency estimation frequency 
                                                         % resolution in Hz
rxParams.isNonPilotAidedRx = true;                       % Flag to indicate Non-Pilot-Aided receiver 
                                                         % for frame synchronization
% Create symbol timing and frequency synchronization System objects by
% using comm.SymbolSynchronizer, comm.CoarseFrequencyCompensator and
% comm.CarrierSynchronizer objects (used in non pilot aided mode).Set the
% modulation to appropriate scheme based on the selected MODCOD for all
% applicable objects.
a = cfgDVBS2.RolloffFactor;
Kp = 4*sin(pi*a/2)/(1-(a^2)/4);
% Input to comm.SymbolSynchronizer should be sampled at 2 samples per
% symbol
symbolSyncSPS = 2;
symbolSync = comm.SymbolSynchronizer( ...
    TimingErrorDetector="Gardner (non-data-aided)", ...
    NormalizedLoopBandwidth=rxParams.symbSyncLoopBW, ...
    DampingFactor=1/sqrt(2), ...
    DetectorGain=Kp, ...
    SamplesPerSymbol=symbolSyncSPS);
if cfgDVBS2.MODCOD > 11
    modScheme = "8PSK";
else
    modScheme = "QPSK";
end
coarseFreq = comm.CoarseFrequencyCompensator(Modulation=modScheme,...
    Algorithm="FFT-based", ...
    SampleRate=Fsamp, ...
    FrequencyResolution=rxParams.coarseFreqResolution);
phaseSync = comm.CarrierSynchronizer(Modulation=modScheme, ...
    SamplesPerSymbol=1, ...
    NormalizedLoopBandwidth=rxParams.carrSyncLoopBW);
if modScheme == "8PSK"
    % Define custom phase offset that DVB-S2 describes for 8-PSK
    phaseSync.ModulationPhaseOffset="Custom";
    phaseSync.CustomPhaseOffset = pi/4;
end

% Initialize the raised cosine receive filter
recFilter = comm.RaisedCosineReceiveFilter( ...
    RolloffFactor=a, ...
    InputSamplesPerSymbol=simParams.sps, ...
    DecimationFactor=simParams.sps/2, ...
    FilterSpanInSymbols=20);

% Initialize reference PLHeader for specified MODCOD
refPLHeader = rxParams.refPLHeader;
[numFramesLost, pktsErr, bitsErr, pktsRec] = deal(0);
% Initialize data indexing variables
stIdx = 0;
dataSize = rxParams.inputFrameSize;
plFrameSize = rxParams.plFrameSize;
xFecFrameSize = plFrameSize-90;

Timing and Carrier Synchronization and Data Recovery

To synchronize the received data and recover the input bit stream, the distorted DVB-S2 waveform samples are processed one frame at a time by following these steps.

Estimate and apply coarse frequency offset correction. The comm.CoarseFrequencyCompensator uses an FFT-based estimation for coarse frequency offset correction.
Apply matched filtering, outputting at the rate of two samples per symbol.
Apply symbol timing synchronization using the Gardner timing error detector with an output generated at the symbol rate. The comm.SymbolSynchronizer object handles timing error detection and compensation.
Estimate and apply fine frequency and phase error compensation. The comm.CarrierSynchronizer object handles both fine frequency error and phase offsets as well.
Apply frame synchronization to detect the start of frame.
Estimate and compensate for residual phase ambiguity using a locally generated reference PL header.
Decode the PL header, and compute the transmission parameters.
Demodulate and decode the PL frames.
Perform CRC check on the BB header, if the check passes, recover the header parameters.
Regenerate the input stream of data or packets from BB frames.

while stIdx < length(rxIn)

    % Use one DVB-S2 PL frame for each iteration.
    endIdx = stIdx + rxParams.plFrameSize*simParams.sps;
    % Frame Counter
    rxParams.frameCount = round(endIdx/(rxParams.plFrameSize*simParams.sps));
    % In the last iteration, all the remaining samples in the received
    % waveform are considered.
    isLastFrame = endIdx > length(rxIn);
    endIdx(isLastFrame) = length(rxIn);
    % Get waveform of length equal to a full PLFrame
    syncIn = rxIn(stIdx+1:endIdx);
    if ~isLastFrame
        if  rxParams.frameCount <=  rxParams.symbSyncLock + 1
            % Coarse Frequency compensation
            filtIn = coarseFreq(syncIn);
            % Matched Filtering
            filtOut =  recFilter(filtIn);
            % Symbol timing synchronization
            timeSyncOut = symbolSync(filtOut);
            % Phase synchronization
            frameSyncIn = phaseSync(timeSyncOut);
            % Performing frequency and phase compensation provides better
            % frame synchronization accuracy
            if  rxParams.frameCount ==  rxParams.symbSyncLock + 1
                % Frame synchronization to identify start of frame
                rxParams.syncIndex = HelperDVBS2FrameSync(...
                    [rxParams.syncBuffer;frameSyncIn],rxParams.isNonPilotAidedRx);
            end
            rxParams.cfBuffer = timeSyncOut(rxParams.syncIndex:end);
        else
            if rxParams.frameCount > rxParams.symbSyncLock
                % Coarse frequency estimation and compensation
                [cFreqDataOut,freqEst]  = coarseFreq(syncIn);
                fprintf("Estimated coarse frequency offset= %s Hz\n",freqEst);
                % Matched filtering
                filtOut =  recFilter(cFreqDataOut);
                % Timing synchronization
                timeSyncOut = symbolSync(filtOut);
                % Frame synchronization
                rxParams.syncIndex = HelperDVBS2FrameSync(...
                    [rxParams.syncBuffer;timeSyncOut],rxParams.isNonPilotAidedRx);
                rxParams.syncIndex = rxParams.syncIndex - 90;
                for n = 1:length(rxParams.syncIndex)
                    if rxParams.syncIndex(n) <= 0
                        rxParams.syncIndex(n) = rxParams.syncIndex(n) + rxParams.plFrameSize;
                    end
                    % The PL frame start index lies somewhere in the
                    % middle of the chunk being processed. From fine
                    % frequency estimation onwards, the processing
                    % happens as a PL frame. A buffer is used to store
                    % symbols required to fill one PL frame.
                    if isLastFrame
                        resCnt = resSymb - length(timeSyncOut);
                        if resCnt <= 0
                            fineFreqIn = [rxParams.cfBuffer; timeSyncOut(1:resSymb)];
                        else
                            fineFreqIn = [rxParams.cfBuffer; timeSyncOut; zeros(resCnt, 1)];
                        end
                    else
                        fineFreqIn = [rxParams.cfBuffer; timeSyncOut(1:rxParams.syncIndex(n)-1)];
                    end
                    fineFreqIn = fineFreqIn/sqrt(mean(abs(fineFreqIn).^2));
                    % Fine frequency and phase compensation
                    syncOutTemp = phaseSync(fineFreqIn);
                    if length(fineFreqIn) == plFrameSize
                        isValid = true;
                        dataStInd = rxParams.frameCount-1;
                    else
                        isValid = false;
                    end
                    % Use SOF field along with the SOF from reference
                    % header generated locally to estimate and compensate
                    % any residual phase offset
                    phSyncOut = angle(sum(syncOutTemp(1:26).*conj(refPLHeader(1:26))));
                    syncOut = syncOutTemp.*exp(-1j*phSyncOut);
                    % Update the buffers and counters.
                    if n~=length(rxParams.syncIndex)
                        rxParams.cfBuffer = timeSyncOut(rxParams.syncIndex(n):rxParams.syncIndex(n+1)-1);
                    else
                        rxParams.cfBuffer = timeSyncOut(rxParams.syncIndex(n):end);
                    end
                end

                if isValid  % Data valid signal
                    % Normalize input to bit recovery to account for phase
                    % ambiguity compensation
                    syncOut = syncOut/sqrt(mean(abs(syncOut).^2));
                    rxPLHeader = syncOut(1:90);
                    % PLHeader decoding
                    phyParams = dvbsPLHeaderRecover(rxPLHeader,Mode="DVB-S2/S2X regular");
                    M = phyParams.ModulationOrder;
                    % When header decoding leads to a reserved MODCOD
                    % value, the LDPCCodeIdentifier field is empty
                    try
                        R = eval(phyParams.LDPCCodeIdentifier);
                    catch
                        R = 0;
                    end
                    fecFrame = phyParams.FECFrameLength;
                    xFECFrameLen = fecFrame/log2(M);
                    % Validate the decoded PL header.
                    if M ~= rxParams.modOrder || R ~= rxParams.codeRate || ...
                            fecFrame ~= rxParams.cwLen
                        fprintf("%s\n","PL header decoding failed")
                        numFramesLost = numFramesLost + 1;
                    else % Demodulation and decoding
                        for frameCnt = 1:length(syncOut)/plFrameSize
                            rxFrame = syncOut((frameCnt-1)*plFrameSize+1:frameCnt*plFrameSize);
                            % Estimate noise variance 
                            nVar = nVarEst(rxFrame(1:90),refPLHeader);
                            % Recover the input bit stream by using
                            % dvbs2BitRecover function
                            [decBitsTemp, isFrameLost, pktCRC]  = dvbs2BitRecover(rxFrame,nVar);
                            decBits = decBitsTemp{:};

                            % Compute the number of frames lost. CRC failure of baseband header
                            % is considered a frame loss.
                            if ~isFrameLost && length(decBits) ~= dataSize
                                isFrameLost = true;
                            end
                            if ~isFrameLost && ~(strcmpi(cfgDVBS2.StreamFormat,"GS") && ~rxParams.UPL)
                                % Compute the packet error rate for TS or GS packetized
                                % mode.
                                pktsErr = pktsErr + numel(pktCRC{:}) - sum(pktCRC{:});
                                pktsRec = pktsRec + numel(pktCRC{:});
                            end
                            if ~isFrameLost
                                ts = sprintf("%s","BB header decoding passed.");
                            else
                                ts = sprintf("%s","BB header decoding failed.");
                            end
                            % Compute the bits in error.
                            bitInd = (dataStInd-1)*dataSize+1:dataStInd*dataSize;
                            if isLastFrame && ~isFrameLost
                                bitsErr = bitsErr + sum(data(bitInd) ~= decBits);
                            else
                                if ~isFrameLost
                                    bitsErr = bitsErr + sum(data(bitInd) ~= decBits);
                                end
                            end
                            numFramesLost = isFrameLost + numFramesLost;
                            fprintf("%s(Number of frames lost = %1d)\n",ts,numFramesLost);                            
                        end
                    end
                end

            end
        end
    end
    stIdx = endIdx;
    rxParams.syncBuffer = timeSyncOut(end-89:end);
end

Estimated Frequency = 1.999969e+06 Hz
Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

Estimated Frequency = 1.999969e+06 Hz

BB header decoding passed.(Number of frames lost = 0)

% Synchronized data constellation plot
syncConst = comm.ConstellationDiagram(Title="Synchronized data", ...
    XLimits=[-2 2],YLimits=[-2 2], ...
    ShowReferenceConstellation=false);
syncConst(syncOut)

% Compute PER
per = pktsErr/pktsRec;
fprintf("Packet error rate: %f\n",per)

Packet error rate: 0.000000

ber = bitsErr/length(data);
fprintf("Bit error rate: %f\n",ber)

Bit error rate: 0.000000

% Estimate noise variance on PL header
function nVarEst = nVarEst(rxData,refData)
pSigN = mean(abs(rxData).^2);
pSig = abs(mean(rxData.*conj(refData))).^2;
nVarEst = abs(mean(pSigN-pSig));
end

Further Exploration

The operating Es/No range of the DVB-S2 standard being very low requires the normalized loop bandwidth of the symbol synchronizer to be very small for accurate estimation. This parameter is set via rxParams.symbSyncLoopBW.

Configure Symbol Timing Synchronization Parameters

Try running the simulation using the symbol timing synchronizer configured with a normalized loop bandwidth of 1e-4. If the symbol timing loop does not converge, try decreasing the rxParams.symbSyncLoopBW and increasing the rxParams.symbSyncLock. To achieve convergence of the timing loop, the ratio rxParams.symbSyncLoopBW/simParams.sps must be greater than 1e-5.

Configure Frame Synchronization Parameters

HelperDVBS2FrameSync.m helper function processes the number of frames specified in rxParams.symbSyncLock. If HelperDVBS2FrameSync.m does not detect the start of frame, increase the number of frames required for frame synchronization by increasing the value of rxParams.symbSyncLock.

Configure Carrier Synchronization Parameters

Try running the simulation using different frequency resolution values. If the frequency error estimates are far from the actual value, try to vary the frequency resolution to achieve better error estimates.

A closed-loop PLL performs fine frequency offset compensation, with a normalized loop bandwidth value of 1e-3. In case synchronization fails to detect a valid signal, reduce the rxParams.carrSyncLoopBW value. After refining the synchronization parameters in the rxParams structure, perform the BER simulation for the updated configuration.

Supporting Files

The example uses these helper functions:

HelperDVBS2RxInputGenerate.m: Generate DVB-S2 waveform samples distorted with RF impairments and structure of parameters for receiver processing
HelperDVBS2PhaseNoise.m: Generate phase noise samples for different DVB-S2 phase noise masks and apply it to the input signal
HelperDVBS2FrameSync.m: Perform frame synchronization and detect the start of frame

References

ETSI Standard EN 302 307-1 V1.4.1(2014-11). Digital Video Broadcasting (DVB); Second Generation Framing Structure, Channel Coding and Modulation Systems for Broadcasting, Interactive Services, News Gathering and other Broadband Satellite Applications (DVB-S2).
ETSI Standard TR 102 376-1 V1.2.1(2015-11). Digital Video Broadcasting (DVB); Implementation Guidelines for the Second Generation System for Broadcasting, Interactive Services, News Gathering and other Broadband Satellite Applications (DVB-S2).
Mengali, Umberto, and Aldo N.D'Andrea. Synchronization Techniques for Digital Receivers. New York: Plenum Press,1997.
E. Casini, R. De Gaudenzi, and Alberto Ginesi. "DVB‐S2 modem algorithms design and performance over typical satellite channels." International Journal of Satellite Communications and Networking 22, no. 3 (2004): 281-318.
Michael Rice, Digital Communications: A Discrete-Time Approach. New York: Prentice Hall, 2008.