DVB-S2X Link Simulation with RF Impairments and Corrections for Regular Frames
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 extended (DVB-S2X) link that has constant coding and modulation for regular frames. The example describes the symbol timing and carrier synchronization strategies in detail emphasizing on how to estimate the RF front-end impairments under 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.
Introduction
The DVB-S2X standard, an extension of the DVB-S2 specification, enhances the support provided for core DVB-S2 applications and improves overall efficiency over satellite links. The DVB-S2X standard supports these additional features:
More granularity of modulation and code rates
Smaller filter roll-off options for better utilization of bandwidth
Constellations optimized for linear and nonlinear channels
More scrambling options for critical co-channel interference scenarios
DVB-S2X caters to a variety of different target applications, and the receivers are subjected to different types and levels of RF impairments based on the application used. This example designs the synchronization aspects of a DVB-S2X receiver used for core DVB-S2 applications. The example supports the newer code rates, higher modulation schemes such as 64, 128 and 256 APSK, and smaller filter roll-off options.
ETSI EN 302 307-2 Section 6 Table 20a and Table 20c [1] summarizes the Quasi-Error-Free (QEF) performance requirement over an AWGN channel for different modulation schemes and code rates. The operating range for different transmission modes can be considered as +3 or -2 dB from the point where QEF performance is observed. Because the operating range is low, carrier and symbol timing synchronization strategies are challenging design problems.
This diagram summarizes the example workflow.
Main Processing Loop
The example processes 50 physical layer (PL) frames of data with the set to 15.8 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 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-S2X 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.
These block diagrams show the synchronization and input bit recovery workflows.
DVB-S2X Configuration in Pilot-Aided Mode
Specify the cfgDVBS2X structure to define DVB-S2X transmission configuration parameters. PLSDecimalCode 129 and 131 are not supported because they are used for generating VL-SNR frames. Only the regular frames are supported.
cfgDVBS2X.StreamFormat ="TS" ; cfgDVBS2X.PLSDecimalCode = 191; % 64APSK 7/9 with pilots cfgDVBS2X.RolloffFactor = 0.35; cfgDVBS2X.SamplesPerSymbol = 2
cfgDVBS2X = struct with fields:
StreamFormat: "TS"
PLSDecimalCode: 191
RolloffFactor: 0.3500
SamplesPerSymbol: 2
Simulation Parameters
The DVB-S2X 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 11% of the input symbol rate. 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 = cfgDVBS2X.SamplesPerSymbol; % Samples per symbol simParams.numFrames = 50; % Number of frames to be processed simParams.chanBW = 36e6; % Channel bandwidth in Hertz simParams.hasCFO = true; simParams.cfo = 2e6; % Carrier frequency offset in Hertz simParams.hasSCO = true; simParams.sco = 2; % Sampling clock offset in parts % per million simParams.hasPN = true; simParams.phNoiseLevel ="Low"; % Phase noise level provided as % "Low", "Medium", or "High" simParams.EsNodB = 15.8; % Energy per symbol to noise ratio % in decibels
This table defines the phase noise mask (dBc/Hz) used to generate the phase noise applied to the transmitted signal. These noise masks are taken from ETSI TR 102 376-1 Section 4.3.2.1.3 Figure 12 [2].
Generate DVB-S2X Waveform Distorted with RF Impairments
To create a DVB-S2X waveform, use the HelperDVBS2XRxInputGenerate helper function with the simParams and cfgDVBS2X structures as inputs. The function returns the data signal, transmitted and received waveforms, physical layer configuration parameters as a structure, 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 transmitted symbols and the spectrum of the transmitted and received waveforms.
[data,txOut,rxIn,phyConfig,rxParams] = HelperDVBS2XRxInputGenerate(cfgDVBS2X,simParams); disp(phyConfig)
FECFrame: "normal"
ModulationScheme: "64APSK"
LDPCCodeIdentifier: "7/9"
sps = cfgDVBS2X.SamplesPerSymbol; % Transmitted and received signal spectrum visualization Rsymb = simParams.chanBW/(1 + cfgDVBS2X.RolloffFactor); Fsamp = Rsymb*sps; fprintf('Symbol rate in Hz = %f\n',Rsymb)
Symbol rate in Hz = 26666666.666667
% Transmitted signal constellation plot txConst = comm.ConstellationDiagram(Title = "Transmitted data", ... AxesLimits = [-1 1], ... ShowReferenceConstellation = false, ... SamplesPerSymbol = sps); txConst(txOut(1:rxParams.plFrameSize*sps))
% Transmitted and received signal spectrum visualization specAn = spectrumAnalyzer(SampleRate = Fsamp, ... ChannelNames = ["Transmitted waveform" "Received waveform"], ... ShowLegend = true); specAn([txOut(1:rxParams.plFrameSize*sps), rxIn(1:rxParams.plFrameSize*sps)]);
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.
Symbol Timing Synchronization Parameters
The Gardner algorithm performs symbol timing synchronization. The preferred loop bandwidth for this synchronization depends on the setting. When you decrease , you can reduce the loop bandwidth to filter out more noise during acquisition.
rxParams.symbSyncLoopBW = 1e-4; % Symbol timing synchronizer loop bandwidth % normalized by symbol rate rxParams.symbSyncLock = ceil(1e5/rxParams.plFrameSize); % Number of frames required for symbol % timing error convergence
Frame Synchronization Parameters
Frame synchronization can use the PL header alone or both the PL header and Pilots. The value of affects frame synchronization accuracy. For QPSK-modulated frames, using pilots with the PL header improves frame detection accuracy.
rxParams.frameSyncUsePilots = phyConfig.ModulationScheme == "QPSK";Carrier Synchronization Parameters
The carrier frequency estimation algorithm can track carrier frequency offsets up to 11% of the input symbol rate. The coarse frequency estimation, implemented as a frequency locked loop (FLL), reduces the frequency offset to a level that the fine frequency estimator can track.
The fine frequency estimation can track carrier frequency offsets up to 4% of the input symbol rate. The fine frequency estimation must process multiple pilot blocks for the residual carrier frequency offset to be reduced to levels acceptable for the phase estimation algorithm. The phase estimation algorithm can handle residual carrier frequency errors less than 0.02% of the input symbol rate.
The preferred loop bandwidth for carrier synchronization depends on the setting. When you decrease , you can reduce the loop bandwidth to filter out more noise during acquisition.
These settings are assigned in the rxParams structure for synchronization processing. For details on how to set these parameters for low values, see the Further Exploration section.
rxParams.carrSyncLoopBW = 1e-3; % Coarse frequency estimator loop bandwidth % normalized by symbol rate
Initialize Receiver Variables
% Initialize error computing and data indexing parameters [numFramesLost,pktsErr,bitsErr,pktsRec,dataStInd,stIdx] = deal(0); % Variables for storing symbol synchronization output length, estimated coarse % frequency offset, average coarse frequency offset, and % starting index for every PL frame [symSyncOutLen,cCFOEst,cCFOEstMean,syncIndex] = deal([]); % Boolean variable that indicates whether the simulation has reached the last frame, % and whether coarse frequency offset tracking has converged. [isLastFrame,isCoarseFreqLocked] = deal(false); % Counter to track the number of PL frames used for fine frequency % offset estimation numFreqEst = 0; dataSize = rxParams.inputFrameSize; plFrameSize = rxParams.plFrameSize; % Initialize FSM variables % Use the variables to denote current state of receiver % STR - Symbol Timing Recovery, FS - Frame Synchronization, % CFL - Coarse Frequency Loop, FFS - Fine Frequency Synchronization, % PS - Phase Synchronization, FPS - Fine Phase Synchronization % PLR - PL Frame Recovery stateVal = num2cell([1 2 3 4 5 6 7]); [STR, FS, CFL, FFS, PS, FPS, PLR] = stateVal{:}; state = STR; activeState = [true false false false false false false]';
Initialize Receiver Objects
Use pilots for frame synchronization only for QPSK PL frames. You can configure the number of pilot blocks, but ensure that you do not exceed half of the maximum limit per PL frame.For normal FEC frames, it is 8 and for short FEC frames, it is 2.
% Create symbol timing and coarse frequency synchronization System object % by using HelperDVBS2Synchronizer helper object timeFreqSync = HelperDVBS2Synchronizer( ... CarrSyncLoopBW = rxParams.carrSyncLoopBW, ... SymbSyncLoopBW = rxParams.symbSyncLoopBW, ... SamplesPerSymbol = sps, ... DataFrameSize = rxParams.xFecFrameSize); % Create frame synchronization System object by using % HelperDVBS2FrameSynchronizer helper object if cfgDVBS2X.PLSDecimalCode > 215 numPilotBlks = 2; else numPilotBlks = 8; end frameSync = HelperDVBS2FrameSynchronizer( ... UsePilots = rxParams.frameSyncUsePilots, ... PLFrameLength = rxParams.plFrameSize, ... NumOfPilotBlocks = numPilotBlks); % For carrSyncLoopBW of 1e-4, 4e4 pilots are required for FLL convergence. Based % on chosen carrSyncLoopBW and number of pilots in a frame, the minimum % number of frames, calculate the number of frames required for % FLL convergence. coarseCFOEstMinFrames = floor(4/(rxParams.carrSyncLoopBW*length(rxParams.pilotInd)));
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.
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 Gardner TED is not data-aided, so it is performed before carrier synchronization.
Apply frame synchronization to detect the start of frame and to identify the pilot positions.
Estimate and apply coarse frequency offset correction.
Estimate and apply fine frequency offset correction.
Estimate and compensate for residual carrier frequency and phase noise.
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.
fprintf('\nPerforming symbol timing synchronization ...\n');Performing symbol timing synchronization ...
while stIdx < length(rxIn) % Use one DVB-S2 PL frame for each iteration. endIdx = stIdx + rxParams.plFrameSize*sps; % In the last iteration, all the remaining samples in the received % waveform are considered. isLastFrame = endIdx > length(rxIn); if ~isLastFrame rxData = rxIn(stIdx+1:endIdx);
Symbol Timing and Coarse Carrier Frequency Synchronization
[coarseFreqSyncOut,phEst] = timeFreqSync(rxData,syncIndex,isCoarseFreqLocked);
coarseCFOEst = diff(phEst(1:sps:end)/(2*pi));
cCFOEst = [cCFOEst;coarseCFOEst];Finite State Machine Transition Logic
Transition between synchronization stages based on the convergence logic of each stage, continuing until data decoding.
switch state case STR symSyncOutLen = [symSyncOutLen;length(coarseFreqSyncOut)]; if any(abs(diff(symSyncOutLen(1:rxParams.frameCount-1))) > 5) error("Symbol timing synchronization failed. The loop will not " + ... "converge. No frame will be recovered. Update the symbSyncLoopBW " + ... "parameter according to the EsNo setting for proper loop convergence."); end if rxParams.frameCount >= rxParams.symbSyncLock state = FS; figure; scatterplot(coarseFreqSyncOut); title("Constellation after symbol timing synchronization"); fprintf("\nPerforming frame synchronization ...\n"); end case FS activeState(FS) = true; if ~isempty(syncIndex) state = CFL; fprintf("\nPerforming coarse frequency synchronization ...\n"); end case CFL activeState(CFL) = true; cCFOEstMean=[cCFOEstMean;mean(coarseCFOEst)]; %#ok<*AGROW> % Check for FLL convergence based on estimated coarse frequency % offset values across frames if length(cCFOEstMean) > coarseCFOEstMinFrames diffVal = diff(abs(cCFOEstMean)); if all(abs(diffVal(end-2:end)) < 1e-2) isCoarseFreqLocked = true; state = FFS; figure; plot(cCFOEst*Rsymb) grid on ylabel("Estimated coarse frequency offset (Hz)"); xlabel("Data Samples") title("Coarse Frequency Locked Loop Characteristics") fprintf("\nPerforming fine frequency synchronization ...\n"); elseif rxParams.frameCount == simParams.numFrames fprintf("%s\n",["Coarse frequency error estimation has either failed or it did not meet " ... "convergence criteria. Try analyzing the coarse FLL characteristics from the displayed figure." ... "If the CFO estimation (FLL tracking) across samples looks noisy but trends towards the correct estimation, " ... "try reducing carrSyncLoopBW and increasing coarseCFOEstMinFrames. Ensure that simParams.numFrames provides " + ... "enough frames for processing. If the CFO estimation across samples is incorrect, examine syncIndex output. " + ... "Since FLL uses pilots, syncIndex must be accurate for proper estimation"]); end end case FFS activeState(FFS) = true; if rxParams.fineFreqCorrVal ~= 0 rxParams.fineFreqEstTemp(1:end-1) = rxParams.fineFreqEstTemp(2:end); rxParams.fineFreqEstTemp(end) = freqEst; numFreqEst = numFreqEst+1; end % Check whether the normalized fine frequency offset estimation % has converged to within an order of 1e–5. if numFreqEst>=5 cg = abs(diff(rxParams.fineFreqEstTemp(end-numFreqEst+1:end))); if all(cg(end-2:end) < 1e-5) state = PS; activeState(FFS) = false; fprintf("Estimated carrier frequency offset in Hz = %f\n",(coarseCFOEst(end)+freqEst).*Rsymb); fprintf("\nPerforming phase synchronization ...\n"); elseif rxParams.frameCount == simParams.numFrames fprintf("%s\n","Fine frequency error estimation has either failed or it did not meet " + ... "convergence criteria. Analyze rxParams.fineFreqEstTemp to check whether the value " + ... "of (coarseCFOEst(end) + freqEst) * Rsymb is approaching the actual CFO. If the " + ... "estimation is trending in the right direction but the simulation has reached the final frame, " + ... "increase simParams.numFrames to allow more frames for convergence. If the estimation " + ... "appears incorrect, examine the coarse FLL estimation. After coarse correction, the residual " + ... "normalized CFO should be less than 2% of the symbol rate."); end end case PS activeState(PS) = true; if rxParams.prevPhaseEst ~= 0 state = PLR; rxParams.totalSyncFrames = rxParams.frameCount; fprintf("\nPerforming PL frame demodulation and decoding ...\n"); end case PLR activeState(PLR) = true; end if ~isempty(rxParams.cfBuffer) fineFreqIn = [rxParams.cfBuffer; coarseFreqSyncOut(1:rxParams.plFrameSize-length(rxParams.cfBuffer))]; end if ~isempty(syncIndex) rxParams.cfBuffer = coarseFreqSyncOut(syncIndex:end); end
Frame Synchronization
if activeState(FS) syncIndex = frameSync(coarseFreqSyncOut); end
Fine Frequency Error Estimation
if activeState(FFS) rxParams.fineFreqCorrVal = HelperDVBS2FineFreqEst( ... fineFreqIn(rxParams.pilotInd),rxParams.numPilots, ... rxParams.refPilots,rxParams.fineFreqCorrVal); % Normalize the frequency estimate by the input symbol rate % freqEst = angle(R)/(pi*(N+1)), where N (18) is the number of elements % used to compute the mean of auto correlation (R) in % HelperDVBS2FineFreqEst. freqEst = angle(rxParams.fineFreqCorrVal)/(pi*(19)); end
Phase Compensation
if activeState(PS) % Generate the symbol indices using frameCount and plFrameSize. % Subtract 2 from the rxParams.frameCount because the buffer used to get one % PL frame introduces a delay of one to the count. ind = (rxParams.frameCount-2)*plFrameSize:(rxParams.frameCount-1)*plFrameSize-1; phErr = exp(-1j*2*pi*freqEst*ind); fineFreqOut = fineFreqIn.*phErr(:); % Estimate the phase error estimation by using the HelperDVBS2PhaseEst % helper function. [phEstRes,prevPhaseEstTemp] = HelperDVBS2PhaseEst( ... fineFreqOut,rxParams.refPilots,rxParams.prevPhaseEst,rxParams.pilotInd); if rxParams.prevPhaseEst ~= 0 coarsePhaseCompOut = HelperDVBS2PhaseCompensate(rxParams.ffBuffer, ... rxParams.pilotEst,rxParams.pilotInd,phEstRes(2)); end rxParams.ffBuffer = fineFreqOut; rxParams.pilotEst = phEstRes; if rxParams.prevPhaseEst ~= 0 phaseCompOut = coarsePhaseCompOut; end rxParams.prevPhaseEst = prevPhaseEstTemp; end
PL Header Recovery
if activeState(PLR) % Data valid signal % Decode the PL header by using the dvbsPLHeaderRecover % function rxPLHeader = phaseCompOut(1:90); phyParams = dvbsPLHeaderRecover(rxPLHeader,Mode="DVB-S2/S2X regular"); plsDecCode = phyParams.PLSDecimalCode; % Validate the decoded PL header. if plsDecCode ~= cfgDVBS2X.PLSDecimalCode fprintf("%s\n","PL header decoding failed")
PL Data Frame Recovery
else % Demodulation and decoding rxFrame = phaseCompOut(1:plFrameSize); % Estimate noise variance by using % HelperDVBS2NoiseVarEstimate helper function. nVar = HelperDVBS2NoiseVarEstimate(rxFrame,rxParams.pilotInd,... rxParams.refPilots,false); % Recover the input bit stream by using % dvbs2BitRecover function [decBitsTemp, isFrameLost, pktCRC] = dvbs2xBitRecover(rxFrame,nVar); decBits = decBitsTemp{:}; if ~isFrameLost && length(decBits) ~= dataSize isFrameLost = true; end if ~isFrameLost && ~(strcmpi(cfgDVBS2X.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 number of frames lost. CRC failure of baseband header % is considered a frame loss. numFramesLost = isFrameLost + numFramesLost; fprintf("%s(Frame index = %1d, Number of frames lost = %1d)\n",ts,rxParams.frameCount,numFramesLost) % Compute the bits in error. bitInd = (dataStInd-2)*dataSize+1:(dataStInd-1)*dataSize; if isLastFrame && ~isFrameLost bitsErr = bitsErr + sum(data(bitInd) ~= decBits); else if ~isFrameLost bitsErr = bitsErr + sum(data(bitInd) ~= decBits); end end end end end dataStInd = dataStInd + 1; stIdx = endIdx; rxParams.frameCount = rxParams.frameCount + 1; end
Performing frame synchronization ...
Performing coarse frequency synchronization ...
Performing fine frequency synchronization ...
Estimated carrier frequency offset in Hz = 2000582.914082
Performing phase synchronization ...
Performing PL frame demodulation and decoding ...
BB header decoding passed.(Frame index = 44, Number of frames lost = 0) BB header decoding passed.(Frame index = 45, Number of frames lost = 0) BB header decoding passed.(Frame index = 46, Number of frames lost = 0) BB header decoding passed.(Frame index = 47, Number of frames lost = 0) BB header decoding passed.(Frame index = 48, Number of frames lost = 0) BB header decoding passed.(Frame index = 49, Number of frames lost = 0) BB header decoding passed.(Frame index = 50, Number of frames lost = 0)
Visualization and Error Logs
Plot the constellation of the synchronized data and compute the BER and PER.
% Synchronized data constellation plot syncConst = comm.ConstellationDiagram(Title = "Synchronized data", ... AxesLimits = [-1.7 1.7], ... ShowReferenceConstellation = false); syncConst(rxFrame)
% Error metrics display % For GS continuous streams if strcmpi(cfgDVBS2X.StreamFormat,"GS") && ~rxParams.UPL if (simParams.numFrames-rxParams.totalSyncFrames == numFramesLost) fprintf("All frames are lost. No bits are retrieved from BB frames.") else ber = bitsErr/((dataStInd-rxParams.totalSyncFrames)*dataSize); fprintf("EsNo (dB): %1.2e\n",simParams.EsNodB) fprintf("BER : %1.2e\n",ber) end else % For GS and TS packetized streams if pktsRec == 0 fprintf("All frames are lost. No packets are retrieved from BB frames.") else if strcmpi(cfgDVBS2X.StreamFormat,"TS") pktLen = 1504; else pktLen = cfgDVBS2X.UPL; % UP length including sync byte end ber = bitsErr/(pktsRec*pktLen); per = pktsErr/pktsRec; fprintf("EsNo (dB): %1.2e\n",simParams.EsNodB) fprintf("PER: %1.2e\n",per) fprintf("BER: %1.2e\n",ber) end end
EsNo (dB): 1.58e+01
PER: 0.00e+00
BER: 0.00e+00
Further Exploration
For BER simulations in AWGN assuming perfect synchronization, use the dvbs2xBitRecover function to evaluate the receiver performance. See the examples provided in the documentation of the dvbs2xBitRecover function. For details on how to configure the synchronization parameters of the rxParams for other cfgDVBS2X and simParams settings, see the Further Exploration section of DVB-S2 Link Simulation with RF Impairments and Corrections example on how to configure the synchronization parameters of rxParams for other cfgDVBS2X and simParams settings.
Supporting Files
The example uses these helper functions:
HelperDVBS2XRxInputGenerate.m: Generate DVB-S2X waveform samples distorted with RF impairments and structure of parameters for receiver processingHelperDVBS2PhaseNoise.m: Generate phase noise samples for different DVB-S2X phase noise masks and apply it to the input signalHelperDVBS2Synchronizer.m: Perform matched filtering, symbol timing synchronization, and coarse frequency estimation and correctionHelperDVBS2FrameSynchronizer.m: Perform frame synchronization and detect the start of frameHelperDVBS2FineFreqEst.m: Estimate fine frequency offsetHelperDVBS2PhaseEst.m: Estimate carrier phase offsetHelperDVBS2PhaseCompensate.m: Perform carrier phase compensationHelperDVBS2NoiseVarEstimate.m: Estimate noise variance of received data
References
ETSI Standard EN 302 307-2 V1.1.1(2015-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; Part 2: DVB-S2 extensions (DVB-S2X).
ETSI Standard TR 102 376-2 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; Part 2: S2 extensions (DVB-S2X).
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.
