dqpskreceiver.cpp

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

/*****************************************************************************
 * Class -- DQPSKreceiver                                                    *
 * Functions -- ReceiveAndDetect                                             *
 * Returns -- Detected data bits                                             *
 *                                                                           *
 * Note: every time it processes it takes 9 samples(=1 symbol)               *
 *****************************************************************************/

/* user include files. Each file represents a class definition.  */
#include "EnergyDetector.cpp"
#include "TimingRecovererOct13.cpp"
#include "DiffDetector.cpp"

class DQPSKreceiver
{ private:
   int IdNumber;         /* distinguishes different receivers */
   double SymbolSample;  /* temparory storage */
   double DataStrobe[2];        /* for use of detector */
   double CosRailSamples[9];    /* after RRC filtering */
   double SinRailSamples[9];    /* after RRC filtering */
   int CountOne;
   int CountZero;
   int DataMode;

   EnergyDetector ED;
   /* demodulator is the same as modulator except for phase shift */
   modulator DMR;         /* demodulator is the same as modulator */
   RRcFilter RRCF1;       /* filter for cos(or I) rail */
   RRcFilter RRCF2;       /* filter for sin(or Q) rail */
   TimingRecoverer TR;
   /* PhaseCorrector PCR; */
   DiffDetector DDR;

  public:
   DQPSKreceiver(int id)
    { IdNumber=id;
      ED.SetEnergyLevel(34.3908);  /* E=1182.7 starts detection */
      TR.SetThreshold(30000000.1); /* half of third smallest value */
      CountOne=0; 			CountZero=0; 			DataMode=0;
    }
   int ReceiveAndDetect(char In[],char Out1[],char Out2[]);
};

int DQPSKreceiver::ReceiveAndDetect(char In[],char Out1[],char Out2[])
{ ifstream ReadChannelData(In,ios::in);
  ofstream WriteDataBits(Out1,ios::out);
  ofstream WriteDataStrobes(Out2,ios::out);
  double temp=0;             /* temporary storage */
  int TimingIndex;           /* index for timing correction */
  int NumTimingAdj=0;    /* number of timing adjustments in data mode */
  int Bits[2];             /* detected bits */
  cout<<"Receiver "<<IdNumber<<" Receiving..."<<endl;
  cout<<"Receiver "<<IdNumber<<" Detecting..."<<endl;
  while (!ED.EnergyDetect(temp)) /* before demodulation */
   {ReadChannelData>>temp;} /* check for starting of detection */
  for (int i=0; i<9; ++i)
   { ReadChannelData>>SymbolSample; /* initial */
     CosRailSamples[i]=RRCF1.conv(DMR.CosModulation(SymbolSample));
     SinRailSamples[i]=RRCF2.conv(DMR.SinModulation(SymbolSample));
   }
  while (!ReadChannelData.eof())  /* stops until end of symbol samples */
    { DataStrobe[0]=CosRailSamples[8];
      DataStrobe[1]=SinRailSamples[8];
      TimingIndex=TR.TimingCorrection(CosRailSamples,SinRailSamples,DataMode);
      for (int i=TimingIndex; i<9; ++i)
       { ReadChannelData>>SymbolSample;
         CosRailSamples[i]=RRCF1.conv(DMR.CosModulation(SymbolSample));
         SinRailSamples[i]=RRCF2.conv(DMR.SinModulation(SymbolSample));
       }
      /* for timing to be locked, 20 times concecussive detection of zero  */
      /* corssings.                                                        */
      if (TR.IsTimingLock())
       { DDR.detect(DataStrobe,Bits);
         WriteDataStrobes<<DataStrobe[0]<<endl;
         WriteDataStrobes<<DataStrobe[1]<<endl;
         if (CountZero==5)
          { DataMode=1;
            WriteDataBits<<Bits[0]<<endl;
            WriteDataBits<<Bits[1]<<endl;
            if (TimingIndex!=1) ++NumTimingAdj;
          }
         if (Bits[0]==1 && Bits[1]==1 && (!DataMode)) ++CountOne;
         if (CountOne>=20 && (!DataMode))
          { if (Bits[0]==0 && Bits[1]==0) ++CountZero;
            /* condition of loss of data */
            if ((CountZero>=1) && ((Bits[0]==1) || (Bits[1]==1)))
             { cout<<"Data loss,"<<"Receiver "
                   <<IdNumber<<" Shutting down..."<<endl;
               return 0;
             }
            TR.SetThreshold(36000000.1); /* data mode threshold  */
          }
       }
    }
   cout<<"Receiver "<<IdNumber<<" Shuting down..."<<endl;
   cout<<"Receiver "<<IdNumber<<" timing adjustments(data mode)...: "
   <<NumTimingAdj<<endl;
 return 1;
}