timingrecovereroct13.cpp

QPSK调制Modem的C实现及文档说明

/*****************************************************************************
 * Class -- Timing Corrector                                                 *
 *   Functions -- TimingCheck: checks for whether a timing correction is     *
 *                             needed or not.                                *
 *                TimingCorrection: returns a timing index for data strobe   *
 *****************************************************************************/
/* This version changes the IsMidBaud condition */

/*****************************************************************************
 * TimingLoopFilter -- implements a loop filter for timing recovery loop     *
 * funcition -- filter -- implements a first order IIR filter with           *
 *                        difference equation y(k)=Bx(k)+Ay(k-1)             *
 * returns - a filtered error signal                                         *
 * note: A can be found using the matlab function,loopfilter.m .             *
 *****************************************************************************/

 class TimingLoopFilter
 { private:
    double DelayedOutput;
    double IIRconstA,IIRconstB;
   public:              /* f3dB=24Hz */
    TimingLoopFilter() {IIRconstA=0.93535;  IIRconstB=0.06465; DelayedOutput=0;}
    double filter(double erf)
     { DelayedOutput=IIRconstB*erf + IIRconstA*DelayedOutput;
       return DelayedOutput;
     }
 };

 class TimingRecoverer
 { private:
    double Threshold;
    int IsMidBaudZero;
    int TimingCount;
    int count;
    TimingLoopFilter TLF;
   public:
     /* declares timing locked after 10 times no timing offsets */
    TimingRecoverer() { TimingCount=20; count=0; }
    void SetThreshold(double ThV) {Threshold=ThV;}
    int TimingCorrection(double CosSamples[],double SinSamples[],int IsDataMode)
     { double erf;    /* error function value */
       erf=CosSamples[4]*(CosSamples[8]-CosSamples[0])+  /* error function */
           SinSamples[4]*(SinSamples[8]-SinSamples[0]);
       /* loop filter */
       //if (IsDataMode)      /* only passes through loop filter in data mode */
       erf=TLF.filter(erf);      /* cout<<erf<<endl; */ 
       /* check for special case where mid-baud is not a zero crosssing */
       IsMidBaudZero=((CosSamples[4]*CosSamples[4])+(SinSamples[4]*SinSamples[4]))<
                     ((CosSamples[0]*CosSamples[0])+(SinSamples[0]*SinSamples[0])+
                      (CosSamples[8]*CosSamples[8])+(SinSamples[8]*SinSamples[8]));
       /* check for timing drift and make the corresponding adjustments */
       if (fabs(erf)<Threshold)
        { if (IsMidBaudZero)
           { CosSamples[0]=CosSamples[8];
             SinSamples[0]=SinSamples[8];
             ++count;   /* for declaration of timing lock */
             return 1;  /* no timing offset */
           }
          else return 0; /* adds one sample */
        }
       else
        { if (erf<0) return 0;           /* adds one sample */
          else
           { CosSamples[0]=CosSamples[7];
             SinSamples[0]=SinSamples[7];
             CosSamples[1]=CosSamples[8];
             SinSamples[1]=SinSamples[8];
             return 2;                 /* drops one sample */
           }
        }
     }
    int IsTimingLock()
     { if (count>TimingCount) return 1;
       else return 0;
     }
 };