In a complete coherent receiver implementation, carrier recovery is required since the receiver typically does not know the exact phase and frequency of the transmitted carrier. In an analog system this recovery is often implemented with a voltage-controlled oscillator (VCO) that allows for precise adjustment of the carrier frequency based on the output of a phase-detecting circuit.

In our digital application, this adjustment is performed with a numerically-controlled oscillator (NCO) (see Figure 1). A simple scheme for implementing an NCO is based on the following re-expression of the carrier sinusoid:

The goal of the PLL is to maintain a demodulating sine and cosine that match the incoming carrier. Suppose ω c ω c is the believed digital carrier frequency. We can then represent the actual received carrier frequency as the expected carrier frequency with some offset, ω c ˜ = ω c + θ ˜ ⁢n ω c ˜ ω c θ ˜ n . The NCO generates the demodulating sine and cosine with the expected digital frequency ω c ω c and offsets this frequency with the output of the loop filter. The NCO frequency can then be modeled as ω c ^ = ω c + θ ^ ⁢n ω c ^ ω c θ ^ n . Using the appropriate trigonometric identities 1, the in-phase and quadrature signals can be expressed as

The estimated phase mismatch estimate is fed to the NCO via a loop filter, often a simple low-pass filter. For this exercise you can use a one-tap IIR filter,

It is suggested that you start by choosing α=0.6 α 0.6 and K=0.15 K 0.15 for the loop gain. Once you have a working system, investigate the effects of modifying these values.

Your NCO must be able to produce a sinusoid with continuously variable frequency. Computing values of sinθ⁢n θ n on the fly would require a prohibitive amount of computation and program complexity; a look-up table is a better alternative.

Suppose a sine table stores N N samples from one cycle of the waveform: ∀k,k=0…N−1:sin2⁢π⁢kN k k 0 … N 1 2 k N . Sine waves with discrete frequencies ω=2⁢πN⁢p ω 2 N p are easily obtained by outputting every p th p th value in the table (and using circular addressing). The continuously variable frequency of your NCO will require non-integer increments, however. This raises two issues: First, what sort of interpolation should be used to get the in-between sine samples, and second, how to maintain a non-integer pointer into the sine table.

You may simplify the interpolation problem by using "lower-neighbor" interpolation, i.e., by using the integer part of your pointer. Note that the full-precision, non-integer pointer must be maintained in memory so that the fractional part is allowed to accumulate and carry over into the integer part; otherwise, your phase will not be accurate over long periods. For a long enough sine table, this approximation will adjust the NCO frequency with sufficient precision.4

Maintaining a non-integer pointer is more difficult. In earlier exercises, you have used the auxiliary registers (ARx) to manage pointers with integer increments. The auxiliary registers are not suited for the non-integer pointers needed in this exercise, however, so another method is required. One possibility is to perform addition in the accumulator with a modified decimal point. For example, with N=256 N 256 , you need eight bits to represent the integer portion of your pointer. Interpret the low 16 bits of the accumulator to have a decimal point seven bits up from the bottom; this leaves nine bits to store the integer part above the decimal point. To increment the pointer by one step, add a 15-bit value to the low part of the accumulator, then zero the top bit to ensure that the value in the accumulator is greater than or equal to zero and less than 256.5 To use the integer part of this pointer, shift the accumulator contents seven bits to the right, add the starting address of the sine table, and store the low part into an ARx register. The auxiliary register now points to the correct sample in the sine table.

As an example, for a nominal carrier frequency ω=π8 ω 8 and sine table length N=256 N 256 , the nominal step size is an integer p=π8⁢N⁢12⁢π=16 p 8 N 1 2 16 . Interpret the 16-bit pointer as having nine bits for the integer part, followed by a decimal point and seven bits for the fractional part. The corresponding literal (integer) value added to the accumulator would be 16×27=2048 16 2 7 2048 .6

You may want to refer to Proakis and Blahut. These references may help you think about the following questions: