pseudo_channel.c

OFDM是wimax的关键技术

/*****************************************************************************/
/*   FIle Name : pseudo_channel.c                                            */
/*   Description : Wi-Max SC Pseudo Channel Estimatitor                      */
/*                 mode : [3]  1:step 0:bilinear interpolation               */
/*                      : [1:0]  0:drift both in freq & time domain          */
/*                      : [1:0]  1:drift only in freq_domain                 */
/*                 multi : number of multiple paths                          */
/*                 level : White Noise level 0:-120dB@peak 6:-114dB...120:0dB*/
/*                 tx_freqerr : Transmitter's Frequency error                */
/*                            : 0:0ppm 1:0.01ppm -10:-0.1ppm(-0.1<=f<=0.1ppm)*/
/*                 rx_freqerr : Receiver's Frequency error                   */
/*                            : 0:0ppm 1:0.01ppm -10:-0.1ppm(-0.1<=f<=0.1ppm)*/
/*   author : miffie                                                         */
/*   Date   : oct/20/05                                                      */
/*   Copyright (c) 2005 miffie   All rights reserved.                        */
/*****************************************************************************/
//In Wi-MAX SC the SS's clock is locked to BS. 
//And only allowed 1ppm of clock frequecny error.

struct complexset pseudo_channel(struct complexset datain, 
                                char mode, char multi, char level,
                                char tx_freqerr, char rx_freqerr ) { 
int 	ii,kk ;
int 	size ;
int     tmp0 ;
int     startpoint ;
double  tx_clock, rx_clock ;
double  tx_carrierclock, rx_carrierclock ;
double  tx_phase, rx_phase ;
double  rx_time ;
struct 	complex  *top ;
struct 	complex  *cdata ;
struct 	complex  tmp1, tmp2 , tmp3;
int     tx_floor , tx_ceil ;
struct  complexset  ctop ;
double  white ;
char    NO_NOISE = 0 ;
static  double   sample_period = 125 ; //ns //8MHz
static  double   carrier_period = 0.1 ; //ns //10GHz
static  int      delay = 60 ; //ns


   PRINTF("pseudo_channel size=%d multi=%d level=%d tx_freqerr=%d rx_freqerr=%d\n", 
          datain.size , multi, level, tx_freqerr, rx_freqerr) ;
   if (mode<4) { //doubler
     tx_clock = (sample_period/2.0)*(1.0+(tx_freqerr/100000000.0)) ; //ns
     rx_clock = (sample_period)*(1.0+(rx_freqerr/100000000.0)) ; //ns
     size = (datain.size/2) +32 ; //+32 for extention
   } //doubler
   else { //single
     tx_clock = (sample_period)*(1.0+(tx_freqerr/100000000.0)) ; //ns
     rx_clock = (sample_period)*(1.0+(rx_freqerr/100000000.0)) ; //ns
     size = datain.size +32 ; //+32 for extention
   } //single
   tx_carrierclock = carrier_period*(1.0+(tx_freqerr/100000000.0)) ; //ns 
   rx_carrierclock = carrier_period*(1.0+(rx_freqerr/100000000.0)) ; //ns 

   //noises
   NO_NOISE = (multi==0) && (level==0) ; //if 1  NO Noise
   white = pow(2, ((double)level-120.0)/6.0) ; //WhiteNoiseGain
   
   //sampling clock width 
   if (((top = (struct complex *)malloc(size*sizeof(struct complex)) ) == NULL) |
       ((cdata = (struct complex *)malloc((datain.size+200)*sizeof(struct complex)) ) == NULL)){
        PRINTF( " malloc failed in pseudo_channel.c\n") ;
   } //fail
   else { //allocated
     //initialize
     for( ii=0;ii<size;ii++) {//for
       top[ ii ].realp = 0 ;
       top[ ii ].image = 0 ;
     } //for

     for( ii=0;ii<(datain.size+200);ii++) {//for
       cdata[ ii ].realp = 0 ;
       cdata[ ii ].image = 0 ;
     } //for
     //add blank period
     startpoint = (NO_NOISE) ? 16 : int_random( 16 )+16 ;
     for( ii=0;ii<(datain.size);ii++) { //datain 
        cdata[ii+startpoint].realp += datain.data[ ii ].realp ;
        cdata[ii+startpoint].image += datain.data[ ii ].image ;
     } //datain

     //Multi paths generation
     for( kk=0;kk<=multi;kk++) {//for
        //receiver's phase is randomized 
        rx_time = (NO_NOISE) ? 0 : ((double )int_random(1024)/1024.0)*1 ; //ns 2pi=0.1ns
        if (NO_NOISE==0) { //NO_NOISE
          if(kk==0) rx_time += delay ;
          else if (kk>=1) rx_time += delay - gamma_random(delay)  ;
        } //NO_NOISE

        //rotation
        if(kk==0) { //first path's gain is fixed
           tmp3.realp = 1.0 ;
           tmp3.image = 0 ;
        } else { //second path and beyond
          tmp3.realp = ((double)int_random(8)+8)/32.0 ;
          tmp3.image = ((double)int_random(8)+8)/32.0 ;
          tmp3.realp = (int_random(2)) ? -tmp3.realp : tmp3.realp ;
          tmp3.image = (int_random(2)) ? -tmp3.image : tmp3.image ;
        }
        printf("rx_time %8.5f r=%8.5f i=%8.5f\n" , rx_time , tmp3.realp , tmp3.image) ;
   
        for( ii=0;ii<size;ii++) {//for
          //Bi-Linear Interpolation @rx_time
          tx_floor = floor(rx_time/tx_clock) ;
          tx_ceil = tx_floor +1 ;
          //printf("%d cdata=%6.3f %6.3f ", tx_floor, cdata[tx_floor].realp, cdata[tx_floor].image ) ;
          tmp1 = multiply_complex(cdata[tx_floor], tmp3 ) ; 
          //printf("tmp1=%6.3f %6.3f\n", tmp1.realp, tmp1.image ) ;
          tmp2 = multiply_complex(cdata[tx_ceil], tmp3 ) ; 
   
          if (mode&0x8)  { //step
            //step 
            top[ii].realp += tmp1.realp ;
            top[ii].image += tmp1.image ;
          } //step
          else { //else
            //Bi-Linear interpolation
            top[ii].realp += 
            (((rx_time - (tx_clock*tx_floor))* tmp2.realp) +
             (((tx_clock*tx_ceil) - rx_time)* tmp1.realp)) /
             tx_clock  ;
   
            top[ii].image += 
            (((rx_time - (tx_clock*tx_floor))* tmp2.image) +
             (((tx_clock*tx_ceil) - rx_time)* tmp1.image)) /
             tx_clock  ;
          } //else

          if (((mode&0x1)==0)&&(kk==multi)) { //time domain drift & freq
            //noise generation
            tmp0 = int_random( 2 ) ;
            if (tmp0==0) tmp0= -1 ;
            top[ii].realp += (tmp0 * white * gamma_random( 4096 )/4096.0)  ;
            tmp0 = int_random( 2 ) ;
            if (tmp0==0) tmp0= -1 ;
            top[ii].image += (tmp0 * white * gamma_random( 4096 )/4096.0) ;

            //calculate phase drift in Tx
            tx_phase = (rx_time*2.0*pi)/tx_carrierclock ;
            tmp1.realp = cos ( tx_phase ) ;
            tmp1.image = sin ( tx_phase ) ;
            tmp2 = multiply_complex(top[ ii ] , tmp1 ) ;

            //calculate phase drift in Rx
            rx_phase = (rx_time*2.0*pi)/rx_carrierclock ;
            tmp1.realp = cos ( rx_phase ) ;
            tmp1.image = sin ( rx_phase ) ;
            top[ ii ] = multiply_complex(tmp2  ,tmp1 )  ;
          } //time domain drift & freq
          rx_time += rx_clock ;
        } //for
     } //multi 
   } //allocated
   
   ctop.data = top ;
   ctop.size = size ;
   free( datain.data ) ;
   free( cdata ) ;
   return( ctop ) ;
}//pseudo_channel