Abstract:
The present invention discloses a novel multi-channel timing recovery scheme that utilizes a shared CORDIC to accurately compute the phase for each tone. Then a hardware-based linear combiner module is used to reconstruct the best phase estimate from multiple phase measurements. The firmware monitors the noise variance for the pilot tones and determines the corresponding weight for each tone to ensure that the minimum phase jitter noise is achieved through the linear combiner. Then a hardware-based second-order timing recovery control loop generates the frequency reference signal for VCXO or DCXO. A single sequentially controlled multiplier is used for all multiplications in the control loop.

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
       [0001]    The present application claims the benefit of provisional application No. 60/753,616 filed Dec. 23, 2005, the content of which is hereby incorporated by reference in its entirety. 
     
    
     FIELD OF THE INVENTION 
       [0002]    The present invention relates to a timing recovery system, more particularly to a hardware-based multi-channel timing recovery system with CORDIC processing. 
       BACKGROUND OF THE INVENTION 
       [0003]    Timing recovery is a very important receiver function for DMT-based VDSL2 systems. It is vital to design a good timing recovery system to suppress the jitter noise to a level that is comparable to the receiver noise in the loop. Otherwise, the receiver performance will be limited by the poor timing recovery response. In DMT-based systems, single or multiple frequency tones are used as pilot tones that embed the timing phase signals. The timing recovery module reconstructs the phase information from the pilot tones, which is used as reference to the timing recovery control loop. The timing recovery control loop produces frequency control signal to adjust the local clock frequency correspondingly to match the transmitter system clock. In order to achieve superior performance, it is important to reconstruct high-accurate phase information from the pilot tones. 
         [0004]    In VDSL2 systems, timing recovery or clock recovery is always a basic building block. Usually the transceivers at the central office drive the DAC signal out and sample the ADC data at a local crystal oscillator. At the customer premise, the transceiver also drives out the DAC signal and samples ADC signal at a local clock. It is impossible to have the exactly same crystal oscillator frequency on both the central office and the customer premises. Therefore, timing recovery system is utilized at the customer premise to recovery the clock information so that effectively the transceivers on both sides have the same clock frequency. 
         [0005]    Timing recovery systems usually consist of the phase detection module and the second-order control loop. From the received signal, the phase detection module retrieves the clock frequency information that is embedded by the transceivers on the central office. The clock frequency information is basically related to the clock frequency difference between the master clock on the central office and the slave clock on the customer premises. The frequency difference is then used to drive the second-order control loop to adjust the slave clock through the voltage-controlled crystal oscillator (VCXO) or digitally-controlled crystal oscillator (DCXO). With the communication channel as a part of the closed-loop system, the frequency difference eventually will be driven to zero which means that the slave clock on the customer premise has the same clock frequency as the master clock on the central office. 
         [0006]    The timing recovery system design shall be considered an integrated part of the transceiver communication systems. An over-designed system could waste the system cost including hardware and firmware. An under-designed system could limit the overall system performance. One important factor that affects the timing recovery system performance is the measurement noise. The measurement noise comes primarily from the crosstalk, RF interference, and board AWGN. For a single pilot tone scheme, the performance will significantly deteriorate if the measurement noise on the chosen pilot tone suddenly becomes worse due to new noise source. With single pilot tone scheme, the modem may have to go to retrain in order to choose another pilot tone so that the system performance will not be limited by the clock jitter noise. However, if multiple pilot tones are used, the adaptation scheme running on the hardware or firmware can quickly pick up the affected tone and limit its deteriorating effect by reducing its corresponding weight. Therefore, the performance can be maintained and the modem does not necessarily go to retrain. 
         [0007]    On the other hand, the phase estimation itself could affect the system performance. Usually in a DMT-based system, the phase estimation is extracted from the FFT outputs for the selected pilot tones, which are basically complex vector with real and imaginary values. The phase estimation module needs to reconstruct the phase information from those real and imaginary values. How accurate is the phase estimation also significantly affects the overall system performance. 
       SUMMARY OF THE INVENTION 
       [0008]    The present invention defines and implements a novel multi-channel timing recovery scheme that utilizes a shared CORDIC (Coordinate-Rotation Digital Computer) to accurately compute the phase for each tone. Then a hardware-based linear combiner module is used to reconstruct the best phase estimate from multiple phase measurements. The firmware monitors the noise variance for the pilot tones and determines the corresponding weight for each tone to ensure that the minimum phase jitter noise is achieved through the linear combiner. Then a hardware-based second-order timing recovery control loop generates the frequency reference signal for VCXO (Voltage-Controlled Crystal Oscillator) or DCXO (Digitally-Controlled Crystal Oscillator). A single sequentially controlled multiplier is used for all multiplications in the control loop. 
         [0009]    In accordance with an embodiment of the invention, a timing recovery system comprises a phase error estimator module for producing a pilot phase error vector for each pilot tone; a CORDIC processing module for computing the exact angle error vector for each pilot tone after it receives the pilot phase error vectors from the phase error estimator module; a linear combiner module for combining all the angle error vectors of multiple pilot tones from the CORDIC processing module and forming a single phase error reference signal; a 2 nd  order control loop for generating control signal that is started after the linear combiner module already combined all the angle errors; and a pipeline stage controller for controlling the flow of the data across the timing recovery system and determines when the data will be passed to the next module and when the next module shall start processing the incoming data; wherein all the multiplication operations in the timing recovery loop are carried out by a sequentially shared single multiplier. 
         [0010]    Our focus is VDSL2 application. However, the same technology is applicable to other applications such as WiMAX etc. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS  
         [0011]    These and other features, aspects, and advantages of the present invention will become better understood with regard to the following description, appended claims, and accompanying drawings, where: 
           [0012]      FIG. 1  shows the top functional diagram of our timing recovery system design. 
           [0013]      FIG. 2  shows the hardware architecture for the phase error estimator module. 
           [0014]      FIG. 3  shows the CORDIC processing diagram. 
           [0015]      FIG. 4  shows the hardware architecture of the linear combiner module. 
           [0016]      FIG. 5  shows the hardware architecture for the timing-recovery second-order control loop. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Timing Recovery Hardware Architecture Diagram 
       [0017]    In our timing recovery system design, we carefully identify the boundary between the hardware and firmware to achieve an optimal solution in terms of hardware cost and firmware speed requirement.  FIG. 1  shows the top functional diagram of our timing recovery system design. In our design, based on the firmware configuration, two types of data are required. For reference-based pilot recovery, the pilot constellations (complex values in frequency domain after FFT) are needed. For decision-driven pilot recovery, the slice error values (complex values given by slicer in demodulator) are required. The phase error estimator block processes the raw data of either pilot constellations or slice errors to produce the pilot phase error vector. Then the vector is passed to the cordic processing module to generate exact angle error vector in radius. The angle error vector is combined in the linear combiner module to increase the accuracy of phase error estimate. Furthermore, the combine phase error is sent to the second order control loop to generate control signal for VCXO or DCXO control. The above process is controlled by a centralized pipeline stage controller while the shared multiplier unit is used to carry out the arithmetic calculation during the process to reduce the hardware cost. The access to the shared multiplier unit is controlled by the centralized pipeline stage controller. 
         [0018]    As we mentioned before, all the multiplication operations in the timing recovery loop are carried out by a shared single multiplier. The reason that we can use a single multiplier is based on the fact that the timing recovery loop bandwidth requirement is much narrower than the actual system clock frequency. VDSL2 uses two symbol rates 4.3125 kHz and 8.625 kHz. For a given system clock such as 141.312 MHz, up to 16384 clock cycles can be used for the share multiplier to support the multiplication processing requirement of the timing recovery modules. On the other hand, the timing recovery is by natural a sequential processing. The second-order control loop can only be started after the linear combiner already combined all the angle errors from the CORDIC processing module. Similarly the CORDIC processing module can only compute the phase angle for each pilot tone after it receives the complex phase error coordinates from the phase error estimator module. So, by sequentially sharing the multiplier across all processing modules in our timing recovery system, we reduce the hardware cost while not incurring any performance effect at all. 
         [0019]    The pipeline stage controller determines which input shall be multiplexed into the multiplier and how the output shall be registered by various registers in our timing recovery system to storing intermediate or final results. In addition, the pipeline stage controller controls the flow of the data across the timing recovery system and determines when the data will be passed to the next module and when the next module shall start processing the incoming data etc. Effectively it carries the coordination for the whole timing recovery system. 
       Phase Error Estimator Module 
       [0020]    The hardware-based phase error estimator is the first processing module in our timing recovery system and it computes the phase error from the pilot tone constellations (in pilot-directed mode) or the pilot tone slicer outputs (in data-directed mode with no explicit pilot tone). The phase error estimate module is configurable to support both the initial acquisition stage and the tracking stage that follows. During the initial acquisition stage, a single-frequency sinusoid is transmitted on each pilot tone. The receiver needs to reconstruct the phase different between two consecutive symbols, which is effectively the phase error caused by the timing clock difference. In the pilot-directed mode, it is done by multiplying the conjugate of the current FFT tone output with the previous FFT tone output as in the following formula: 
         [0000]    
       
         
           
             
               
                 
                   
                     D 
                     
                       p 
                       , 
                       k 
                     
                   
                   = 
                     
                    
                   
                     
                       C 
                       
                         p 
                         , 
                         k 
                       
                       * 
                     
                     × 
                     
                       C 
                       
                         p 
                         , 
                         
                           k 
                           - 
                           1 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       ( 
                       
                         
                           R 
                           
                             p 
                             , 
                             k 
                           
                         
                         - 
                         
                           j 
                            
                           
                               
                           
                            
                           
                             I 
                             
                               p 
                               , 
                               k 
                             
                           
                         
                       
                       ) 
                     
                     × 
                     
                       ( 
                       
                         
                           R 
                           
                             p 
                             , 
                             
                               k 
                               - 
                               1 
                             
                           
                         
                         + 
                         
                           j 
                            
                           
                               
                           
                            
                           
                             I 
                             
                               p 
                               , 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         R 
                         
                           p 
                           , 
                           k 
                         
                       
                        
                       
                         R 
                         
                           p 
                           , 
                           
                             k 
                             - 
                             1 
                           
                         
                       
                     
                     + 
                     
                       
                         I 
                         
                           p 
                           , 
                           k 
                         
                       
                        
                       
                         I 
                         
                           p 
                           , 
                           
                             k 
                             - 
                             1 
                           
                         
                       
                     
                     + 
                     
                       j 
                        
                       
                         ( 
                         
                           
                             
                               R 
                               
                                 p 
                                 , 
                                 k 
                               
                             
                              
                             
                               I 
                               
                                 p 
                                 , 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                             
                           
                           - 
                           
                             
                               I 
                               
                                 p 
                                 , 
                                 k 
                               
                             
                              
                             
                               R 
                               
                                 p 
                                 , 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   
                     = 
                       
                      
                     
                       
                         DR 
                         
                           p 
                           , 
                           k 
                         
                       
                       + 
                       
                         j 
                          
                         
                             
                         
                          
                         
                           DI 
                           
                             p 
                             , 
                             k 
                           
                         
                       
                     
                   
                   , 
                 
               
             
           
         
       
     
         [0021]    where p is the pilot index, k is the symbol index, C p,k  is the pilot tone constellation in frequency domain. We can see that four multiplications are needed for each pilot tone. 
         [0022]    In general, during the initial acquisition stage, the VDSL2 CO modems will transmit repetitive pilot-bearer symbols for the VDSL2 CPE modem to recover the master clock frequency used at the central office. After the initial acquisition stage, the slave clock frequency will converge to the master clock frequency so that rest of the training process can be carried out with timing locked. During the showtime (VDSL2 modems start to transmit normal data), two alternative timing tracking methods can be used. One is the pilot-directed, which is the same as in the acquisition stage and dedicated pilot tones are used to carry pilot signals, not the data. The second method is the decision-directed, where no dedicated pilot tones are used and instead the phase information is retrieved from the data bearing tones. 
         [0023]    In the decision-directed method, the angle between the sliced constellation and the raw constellation is treated as the phase error reference for the timing recovery loop as shown in the following formula: 
         [0000]    
       
         
           
             
               
                 
                   
                     D 
                     
                       p 
                       , 
                       k 
                     
                   
                   = 
                     
                    
                   
                     
                       C 
                       
                         p 
                         , 
                         k 
                       
                       * 
                     
                     × 
                     
                       S 
                       
                         p 
                         , 
                         k 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       ( 
                       
                         
                           R 
                           
                             p 
                             , 
                             k 
                           
                         
                         - 
                         
                           j 
                            
                           
                               
                           
                            
                           
                             I 
                             
                               p 
                               , 
                               k 
                             
                           
                         
                       
                       ) 
                     
                     × 
                     
                       ( 
                       
                         
                           SR 
                           
                             p 
                             , 
                             k 
                           
                         
                         + 
                         
                           j 
                            
                           
                               
                           
                            
                           
                             SI 
                             
                               p 
                               , 
                               k 
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         R 
                         
                           p 
                           , 
                           k 
                         
                       
                        
                       
                         SR 
                         
                           p 
                           , 
                           k 
                         
                       
                     
                     + 
                     
                       
                         I 
                         
                           p 
                           , 
                           k 
                         
                       
                        
                       
                         SI 
                         
                           p 
                           , 
                           k 
                         
                       
                     
                     + 
                     
                       j 
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           
                             
                               R 
                               
                                 p 
                                 , 
                                 k 
                               
                             
                              
                             
                               SI 
                               
                                 p 
                                 , 
                                 k 
                               
                             
                           
                           - 
                           
                             
                               I 
                               
                                 p 
                                 , 
                                 k 
                               
                             
                              
                             
                               SR 
                               
                                 p 
                                 , 
                                 k 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   
                     = 
                       
                      
                     
                       
                         DR 
                         
                           p 
                           , 
                           k 
                         
                       
                       + 
                       
                         j 
                          
                         
                             
                         
                          
                         
                           DI 
                           
                             p 
                             , 
                             k 
                           
                         
                       
                     
                   
                   , 
                 
               
             
           
         
       
     
         [0024]    where S p,k =SR p,k +jSI p,k  is the sliced constellation output from the slicer logic. The decision-directed method requires that most of the slicer decisions are correct so that there is no error propagation. In practice, usually the SNR margin is raised on the pilot tones in the decision-directed method so that lower constellation is actually loaded to reduce probability of error for the pilot tones. This ensures the stability of the decision-directed method. Our phase error estimator hardware is designed to handle both methods with a simple configuration flag to indicate which method is currently used. It can be configured by the firmware in the field based on the link requirement. In addition, the pilot tone indices are also configurable by the firmware.  FIG. 2  shows the hardware architecture for the phase error estimator module. Based on the chosen timing recovery method (reference-based and decision-driven) and the pipeline control signal, all the pilot signals (R p,k , I p,k ) and (SR p,k , SI p,k ) are multiplexed into shared multiplier and accumulator to calculate (DR p,k , DI p,k ). 
         [0025]    We assume that the receiver can support up to P pilot tones (R p,k , I p,k ), p=0, 1, . . . , P−1. A pilot method register is used by the firmware to configure which method is used in the timing recovery system, the pilot-directed or the decision-directed. Based on the selected pilot method, either the slicer output (SR p,k , SI p,k ), p=0, 1, . . . , P−1 or the registered previous pilot constellation (R p,k−1 , I p,k−1 ), p=0, 1, . . . , P is used in the phase error calculation, as shown by the mux 0  unit in the figure. The current pilot constellations are latched to the previous constellation registers of (R p,k−1 , I p,k−1 ) by the sequence control logics at the end of computation for each frame, which is shown by the delay unit D. Furthermore, the pipeline stage controller multiplexes the data for each pilot tone to the shared multiplier through the mux 1  and mux 2  in a sequential order. 
       CORDIC Processing 
       [0026]    The phase error estimator module produces the phase error for each pilot tone, which is basically a complex coordinate. Next step is to extract the angle information from the complex coordinate, which is implemented in hardware with the CORDIC processing module. CORDIC stands for coordinate-rotation digital computer. With proper configuration, the CORDIC algorithm can calculate the trigonometric phase with any desired precision. Compared with the table-lookup and power-series expansion, our CORDIC processing based angle estimator reduces the hardware cost in terms of gate count since the CORDIC only uses shifts and adders to calculate the phase rather than multipliers and registers. Although CORDIC algorithm is a general algorithm, we are the first in time to propose this unique hardware approach to combine the CORDIC with VDSL2 timing recovery systems seamlessly. 
         [0027]    For a given complex coordinate D p =DR p +jDI p  (for simplicity, we ignore the symbol index k), we use the CORDIC processing to compute the phase angle e p =tan −1 (DI p /DR p ), which is effectively an iterative approach and is shown in the following equations: 
         [0000]    
       
         
           
             
               S 
               i 
             
             = 
             
               { 
               
                 
                   
                     
                       
                         1 
                       
                       
                         
                           
                             DI 
                             
                               p 
                               , 
                               i 
                             
                           
                           &lt; 
                           0 
                         
                       
                     
                     
                       
                         
                           - 
                           1 
                         
                       
                       
                         
                           
                             DI 
                             
                               p 
                               , 
                               i 
                             
                           
                           ≥ 
                           0 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     DR 
                     
                       p 
                       , 
                       
                         i 
                         + 
                         1 
                       
                     
                   
                 
                 = 
                 
                   
                     
                       DR 
                       
                         p 
                         , 
                         i 
                       
                     
                     - 
                     
                       
                         DI 
                         
                           p 
                           , 
                           i 
                         
                       
                       × 
                       
                         S 
                         i 
                       
                       × 
                       
                         2 
                         
                           - 
                           i 
                         
                       
                        
                       
                         
 
                       
                        
                       
                         DI 
                         
                           p 
                           , 
                           
                             i 
                             + 
                             1 
                           
                         
                       
                     
                   
                   = 
                   
                     
                       
                         DI 
                         
                           p 
                           , 
                           i 
                         
                       
                       + 
                       
                         
                           DR 
                           
                             p 
                             , 
                             i 
                           
                         
                         × 
                         
                           S 
                           i 
                         
                         × 
                         
                           2 
                           
                             - 
                             i 
                           
                         
                          
                         
                           
 
                         
                          
                         
                           e 
                           
                             p 
                             , 
                             
                               i 
                               + 
                               1 
                             
                           
                         
                       
                     
                     = 
                     
                       
                         e 
                         
                           p 
                           , 
                           i 
                         
                       
                       - 
                       
                         
                           S 
                           i 
                         
                         × 
                         
                           arctan 
                            
                           
                             ( 
                             
                               2 
                               
                                 - 
                                 i 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0028]    where i is the iteration index and starts with 0, DR p,0 =DR p , DI p,0 =DI p , and e p,0 =0. In general, number of iteration will determine the angle accuracy. More iteration will produce an angular estimate with higher precision. Based on our accuracy requirement of the overall VDSL2 system, we limit the number of iteration to 14. However, our proposed architecture can be used for any degree of iteration to improve the accuracy further. 
         [0000]      FIG. 3  shows the CORDIC processing diagram. The pilot errors are shifted into the CORDIC processing module one by one through the pilot tone index control signal issued by the pipeline stage controller. Then the pipeline stage controller starts an iteration process for the clocked-in pilot tone error. At the beginning of the iteration, the phase angle register e p,i  is initialized to zero, the DR p,i  register is initialized to DR p , the DI p,i  register is initialized to DI p . After the initialization, the normal iteration process starts. The sign of the DI p,i  is used to choose if or not the output of the shift operations of DI p,i  and DR p,i  need to be negated. The i-shift unit will increase the number of shifts by one after each iteration. On the other hand, the phase angle register e p,i  will accumulate the output of the arctan ROM table of arctan(2 −i ) while the subtract or addition is determined by the sign bit of the DI p,i  register. After N-th iteration (in our design, N=14), the phase angle register e p,i  will be clocked out to the next liner combiner module. 
       Linear Combiner 
       [0029]    The linear combiner module basically combines the phase angle errors of multiple pilot tones and forms a single phase error reference signal for the second-order control loop. Different weights are assigned to different pilot tones based on the noise property. The less the noise on the pilot tone, the higher is the associated weight for combination. Assume that the phase angle error measurement for each pilot tone is e i , i=0,1, . . . , P and their corresponding frequency bins are f i ; i=0,1, . . . , P. In addition, we assume that the measurement noise variance for the phase error angle e i , i=0,1, . . . , P is σ i   2 , i=0,1, . . . , P. The measurement noise on the phase error angle comes from multiple noise sources that include near-end and far-end crosstalk noise, self-echo noise, AWGC, RFI etc. In practical implementation, we can estimate the total effect of all these noise sources with some simple measurement during the training and showtime. For example, before the slave clock is locked to the master clock, we can fix the slave clock and then obtain the measurement noise variance from differentiating the pilot tone phase angles across continuous DMT symbols. After the slave clock and the master clock are locked, the noise variance can be obtained by comparing it with the desired pilot tone phase. In our implementation, the noise variance measurement is conducted in the firmware. During the showtime, the firmware will consistently monitor the noise variance on each configured pilot tones and adapt the weights if the noise condition has changed. Furthermore, the firmware computes the best unbiased phase angle error estimate with minimum measurement variance as the following: 
         [0000]    
       
         
           
             
               
                 e 
                 opt 
               
               = 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     0 
                   
                   
                     P 
                     - 
                     1 
                   
                 
                  
                 
                   
                     w 
                     i 
                   
                    
                   
                     e 
                     i 
                   
                 
               
             
             , 
           
         
       
     
         [0030]    where 
         [0000]    
       
         
           
             
               w 
               i 
             
             = 
             
               
                 
                   
                     f 
                     k 
                     2 
                   
                    
                   
                     σ 
                     i 
                     
                       - 
                       2 
                     
                   
                 
                 
                   
                     ∑ 
                     
                       k 
                       = 
                       0 
                     
                     
                       P 
                       - 
                       1 
                     
                   
                    
                   
                     
                       f 
                       k 
                       2 
                     
                      
                     
                       σ 
                       k 
                       
                         - 
                         2 
                       
                     
                   
                 
               
               . 
             
           
         
       
     
         [0000]    The combination process of e opt  is carried out by the hardware while the weight computation and adaptation is carried out by the firmware. 
         [0031]    The reason to split the firmware and hardware with such a way is based on the system consideration. The timing recovery process needs to be carried out every DMT frame to track the clock jitter. However, the weight coefficients do not need to be modified very often and are based on the channel noise condition that intends to change very slowly. Therefore, our hardware and firmware separation releases the microprocessor from frame-by-frame computation while only running the intelligent operations such as pilot tone noise monitoring and weight adaptation. Those intelligent operations do not require real-time capability on the firmware itself. This will enable the microprocessor to support more ports or to reduce microprocessor speed for less power. 
         [0032]      FIG. 4  shows the hardware architecture of the linear combiner module. The phase angle error for each pilot tone is pushed into the linear combiner module sequentially. The pipeline stage controller identifies the corresponding weight coefficient and generates weight index signal to control the multiplex unit. The shared multiplier is used to compute e i w i  while the pipe state controller controls the multiplex unit to either directly latch the e 0 w 0  to the e register or latch the addition of the previous accumulation value and the current e i w i . The final phase angle error e will be shifted out by the pipeline stage controller after all the pilot angle errors are passed through. 
       Second-Order Control Loop 
       [0033]    The second-order control is the feedback control system that actually produces the VCXO or DCXO control signal from the phase angle error to adjust the slave clock frequency. We use a PI-type second-order system. “P” stands for proportional and “I” stands for integral. In order to achieve superior tracking performance during initial tracking stage, we introduce an anti-windup mechanism into the integral portion to limit the error integration in the loop. In a floating-point implementation, our second-order control loop is as the following: 
         [0034]    Integration: 
         [0000]        I ( n )= I ( n− 1)+ k   i   e ( n ), 
         [0035]    Anti-Windup: 
         [0000]    
       
         
           
             
               
                 I 
                 sat 
               
                
               
                 ( 
                 n 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         R 
                         vco 
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             I 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &gt; 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         - 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             I 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &lt; 
                         
                           - 
                           
                             R 
                             vco 
                           
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         I 
                          
                         
                           ( 
                           n 
                           ) 
                         
                       
                       , 
                     
                   
                   
                     
                       Otherwise 
                       , 
                     
                   
                 
               
             
           
         
       
     
         [0036]    Controller: 
         [0000]        u ( n )= k   p   e ( n )+ I   sat ( n ), 
         [0037]    Output Saturation: 
         [0000]    
       
         
           
             
               
                 u 
                 sat 
               
                
               
                 ( 
                 n 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         R 
                         vco 
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             u 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &gt; 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         - 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             u 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &lt; 
                         
                           - 
                           
                             R 
                             vco 
                           
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         u 
                          
                         
                           ( 
                           n 
                           ) 
                         
                       
                       , 
                     
                   
                   
                     
                       Otherwise 
                       , 
                     
                   
                 
               
             
           
         
       
     
         [0038]    where k p  is the floating-point proportional gain and k i  is the floating-point integral gain. During different tracking phases, they can be chosen from two sets of PI controller parameters: (k pf , k if ) for fast convergence and (k po , k io ) for performance optimization. The steady-state values R vco  of I sat (n) and u(n) depends on the maximum frequency difference between the master and slave clocks. 
         [0039]    However, different strategies need to be explored if the implementation is actually done in a fixed-point environment, which is the case in our second-order control implementation. As we mentioned, our second-order control system is realized in the hardware and it is not cost-efficient to use a floating-point implementation. The key point in the fixed-point implementation is to properly scale the input signal, the internal signals, and the output signal to a relative level. In our implementation, the scaling is economically done through shift operation. The following equations show our fixed-point second-order control loop implementation: 
         [0040]    Input Scaling: 
         [0000]        e   s ( n )=2 S     IN     e ( n ) 
         [0041]    Integration: 
         [0000]        I ( n )= I ( n− 1)+ k   i   e   s ( n ), 
         [0042]    Anti-Windup: 
         [0000]    
       
         
           
             
               
                 I 
                 sat 
               
                
               
                 ( 
                 n 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         R 
                         vco 
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             I 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &gt; 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         - 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             I 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &lt; 
                         
                           - 
                           
                             R 
                             vco 
                           
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         I 
                          
                         
                           ( 
                           n 
                           ) 
                         
                       
                       , 
                     
                   
                   
                     
                       Otherwise 
                       , 
                     
                   
                 
               
             
           
         
       
     
         [0043]    Integral Scaling: 
         [0000]        I   s ( n )=2 S     I     I   sat ( n ) 
         [0044]    Controller: 
         [0000]        u ( n )= k   p   e   s ( n )+ I   s ( n ), 
         [0045]    Output Scaling: 
         [0000]        u   s ( n )=2 S     OUT     u ( n ) 
         [0046]    Output Saturation: 
         [0000]    
       
         
           
             
               
                 u 
                 sat 
               
                
               
                 ( 
                 n 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       
                         R 
                         vco 
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             u 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &gt; 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         - 
                         
                           R 
                           vco 
                         
                       
                       , 
                     
                   
                   
                     
                       
                         
                           if 
                            
                           
                               
                           
                            
                           
                             u 
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                         
                         &lt; 
                         
                           - 
                           
                             R 
                             vco 
                           
                         
                       
                       , 
                     
                   
                 
                 
                   
                     
                       
                         
                           u 
                           s 
                         
                          
                         
                           ( 
                           n 
                           ) 
                         
                       
                       , 
                     
                   
                   
                     
                       Otherwise 
                       , 
                     
                   
                 
               
             
           
         
       
     
         [0047]      FIG. 5  shows the hardware architecture for the timing-recovery second-order control loop. 
         [0048]    While the invention has been described with reference to exemplary embodiments, it will be understood by those skilled in the art that various changes may be made and equivalents may be substituted for elements thereof without departing from the scope of the invention. In addition, many modifications may be made to adapt a particular situation or material to the teachings of the invention without departing from the essential scope thereof. Therefore, it is intended that the invention not be limited to the particular embodiment disclosed as the best mode contemplated for carrying out this invention, but that the invention will include all embodiments falling within the scope of the appended claims.