Summary: The goal of symbol-timing recovery is to sample message signals at the receiver for best performance. After the in-phase and quadrature signals pass through a matched filter, a delay-locked loop attempts to find the peaks in the output waveforms.
This receiver exercise introduces the primary components of a QPSK receiver with specific focus on symbol-timing recovery. In a receiver, the received signal is first coherently demodulated and low-pass filtered (see Digital Receivers: Carrier Recovery for QPSK) to recover the message signals (in-phase and quadrature channels). The next step for the receiver is to sample the message signals at the symbol rate and decide which symbols were sent. Although the symbol rate is typically known to the receiver, the receiver does not know when to sample the signal for the best noise performance. The objective of the symbol-timing recovery loop is to find the best time to sample the received signal.
Figure 1 illustrates the digital receiver system.
The transmitted signal coherently demodulated with both a sine
and cosine, then low-pass filtered to remove the
double-frequency terms, yielding the recovered in-phase and
quadrature signals,
![]() |
If we consider the square wave shown in Figure 2
as a potential recovered in-phase (or quadrature) signal
(i.e., we sent the data
![]() |
![]() |
However, in the presence of noise, the received waveform may
look like that shown in Figure 3.
In this case, sampling at any point other than the symbol
transitions does not guarantee a correct data decision. By
averaging over the symbol duration we can obtain a better
estimate of the true data bit being sent
(
![]() |
![]() |
Note that in both cases the output of the matched filter has
peaks where the matched filter exactly lines up with the
symbol, and a positive peak indicates a
The remainder of this handout describes a symbol-timing
recovery loop for a BPSK signal (equivalent to a QPSK signal
where only the in-phase signal is used). As with the above
examples, a symbol period of
One simple method for recovering symbol timing is performed using a delay-locked loop (DLL). Figure 6 is a block diagram of the necessary components.
![]() |
Consider the sawtooth waveform shown in Figure 4, the output of the matched filter with a square wave as input. The goal of the DLL is to sample this waveform at the peaks in order to obtain the best performance in the presence of noise. If it is not sampling at the peaks, we say it is sampling too early or too late.
The DLL will find peaks without assistance from the user. When it begins running, it arbitrarily selects a sample, called the on-time sample, from the matched filter output. The sample from the time-index one greater than that of the on-time sample is the late sample, and the sample from the time-index one less than that of the on-time sample is the early sample. Figure 7 shows an example of the on-time, late, and early samples. Note in this case that the on-time sample happens to be at a peak in the waveform. Figure 8 and Figure 9 show examples in which the on-time sample comes before a peak and after the peak.
The on-time sample is the output of the DLL and will be used to decide the data bit sent. To achieve the best performance in the presence of noise, the DLL must adjust the timing of on-time samples to coincide with peaks in the waveform. It does this by changing the number of time-indices between on-time samples. There are three cases:
![]() |
![]() |
![]() |
The input to the offset decision block is
The offset decision block could adjust the time at which the
next on-time sample is taken based only on the decision
statistic. However, in the presence of noise, the decision
statistic becomes a less reliable indicator. For that
reason, the DLL adds many successive decision
statistics and corrects timing only if the sum
exceeds a threshold; otherwise, the next on-time sample is
taken
The symbol sampler maintains a counter that decrements every
time a new sample arrives at the output of the matched
filter. When the counter reaches three, the matched-filter
output is saved as the late sample, when the counter reaches
two, the matched-filter output is saved as the on-time
sample, and when the counter reaches one, the matched-filter
output is saved as the early sample. After saving the early
sample, the counter is reset to either
Because the DLL requires a feedback loop, you will have to simulate it on a sample-by-sample basis in MATLAB.
Using a square wave of period
Figure 10 and Figure 11 show the matched filter output and the on-time sampling times (indicated by the impulses) for the beginning of the input, before the DLL has locked on, as well as after 1000 samples (about 63 symbols' worth), when symbol-timing lock has been achieved. For each case, note the distance between the on-time sampling times and the peaks of the matched filter output.
![]() |
![]() |
Once your MATLAB simulation works, DSP implementation is relatively straightforward. To test your implementation, you can use the function generator to simulate a BPSK waveform by setting it to a square wave of the correct frequency for your symbol period. You should send the on-time sample and the matched-filter output to the D/A to verify that your system is working.
As your final project will require some modification to the discussed BPSK signaling, you will want to refer to the listed references, (see Proakis and Blahut, and consider some of the following questions regarding such modifications: