WCDMA_simulation_c_program

/* | Project: WCDMA simulation environment | Module: | Author: Maarit Melvasalo | Date: February 1999 | | History: | March 18, 1999 Maarit Melvasalo | Channel memory vector changed to mode were | several different vectors can be memorized | | May 3, 1999 Maarit Melvasalo | Channel model changed | June 16, 1999 Maarit Melvasalo | Documentation added and cleaning up the code | | Copyright disclaimer: | This software was developed at the National Institute of Standards | and Technology by employees of the Federal Government in the course | of their official duties. Pursuant to title 17 Section 105 of the | United States Code this software is not subject to copyright | protection and is in the public domain. | | We would appreciate acknowledgement if the software is used. | /* * Static data structures. */ #include <stdlib.h> #include <math.h> #include <stdio.h> #include "config_wcdma.h" #include "channel.h" #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif /* TRUE */ /* Channel matrix to keep in memory the channel impulses (both amplitudes and delays and their changes) and previous chips etc /**/ static channel_matrix_double channel_data_double[MAX_CHANNELS]; /* List that keeps record which channel instances are used /**/ static enum instance_state channel_alloc_list_double[MAX_CHANNELS] ; /* General initialization flag /**/ static int general_channel_init_flag_double = FALSE; /* Total number of occupied channels/**/ static int channel_index_double = 0; /* -------------------------------------------------------------------- */ /* * Function: wcdma_channel_init * Desc.: Channel initialization * Allocates memory for the chips that effect the future call time inputs * * Return: instance number or -1 if all instances are already occupied. * * Note: */ /* -------------------------------------------------------------------- */ int wcdma_channel_init_double( double channel_impulse[], /* IN: Channel impulse vector*/ int channel_delays[],/* IN: Delay taps */ int nTaps, /* IN: channel impulse vector size */ int nImpulse, /* IN: number of channel impulse vectors */ double impulse_prob[],/* IN: Channel impulse vector probabilities*/ int steps, /* IN: Total number of frames send during ssim/**/ double esno, /* IN: SNR/**/ double power, /* IN: Power/**/ int nCode /* IN: Length of the spreading code/**/ ){ int i,j,instance,n_intervals,delay_diff; /* * If first call, initialize static data. */ if (general_channel_init_flag_double == FALSE) { for (i=0; i < MAX_CHANNELS; i++) { channel_alloc_list_double[i] = FREE_INSTANCE; } /* for */ general_channel_init_flag_double = TRUE; } /* if general_init_flag */ /* * Find first free instance number. */ instance = -1; for (i=0; i < MAX_CHANNELS; i++) { if (channel_alloc_list_double[i] == FREE_INSTANCE) { instance = i; break; } } if (instance == -1) return(-1); /* no free instances */ if (nCode < 0) return(-1); /* Spreading code length incorrect/**/ /* Store the channel data Note if the channel is changed there might be some old data left in the memory, but this do not effect the calculations. /**/ channel_data_double[instance].n_taps = nTaps; channel_data_double[instance].n_impulses = nImpulse; channel_data_double[instance].cur_impulse = 0; /* Standard noise deviation is calculated for each chip. See Michel C. Jeruchim: "Simulation of communication Systems", Plenum 1992 page. 283 Power = noise power nCode = code length esno = Signal to noise ratio The random number is scaled between -1 and 1 and multiplied by noise_std calculated here. /**/ channel_data_double[instance].noise_std = sqrt(power / nCode / 2 / pow(10.0,(esno/10.0)) ) ; /**/ /* Select the channel mode CONSTANT RANDOM INTERPOL /**/ if( nImpulse == 1) { channel_data_double[instance].mode = CONST;} /* CONSTANT channel model /**/ else if (steps == 0) /* RANDOM channel model /**/ { channel_data_double[instance].mode = RANDOM; /* Calculate cumulative impulse vector probalitites /**/ channel_data_double[instance].cumul_prob[0] = impulse_prob[0]; for (i = 1; i < nImpulse; i++){ channel_data_double[instance].cumul_prob[i] = impulse_prob[i] + channel_data_double[instance].cumul_prob[i-1]; }} else { /* INTERPOLATING channel model /**/ channel_data_double[instance].mode = INTERPOL; /* Define the number of iteration steps in between two channel impulses /**/ n_intervals = ceil (steps / (nImpulse - 1)) + min(1, steps % (nImpulse - 1));/**/ for(j = 0; j<nImpulse; j++){ channel_data_double[instance].max[j] = n_intervals; channel_data_double[instance].use[j] = 0;} } /* Update the channel data matrix for all channel taps /**/ for(i = 0; i < nTaps; i++){ channel_data_double[instance].cur_channel[i] = channel_impulse[i]; channel_data_double[instance].cur_delays[i] = channel_delays[i]; if( channel_data_double[instance].mode == RANDOM){ /* RANDOM channel model Save all the impulses and delays /**/ for(j = 0; j < nImpulse-1; j++){ channel_data_double[instance].amplitudes[j][i] = channel_impulse[j * nTaps + i]; channel_data_double[instance].delays[j][i] = channel_delays[j * nTaps + i]; }} else if( channel_data_double[instance].mode == INTERPOL){ /* INTERPOLATING channel model Calculate the derivates of the amplitudes and the number of timesteps between delay tap changes (and the direction of the change) /**/ for(j = 0; j< nImpulse-1; j++){ channel_data_double[instance].amplitudes[j][i] = (channel_impulse[(j+1) * nTaps + i] - channel_impulse[j * nTaps + i])/n_intervals; delay_diff = channel_delays[(j+1) * nTaps + i] - channel_delays[j * nTaps + i] ; if( delay_diff != 0) { channel_data_double[instance].delays[j][i] = ( n_intervals / (abs(delay_diff)+1) + min(1, n_intervals % (abs(delay_diff)+1))) ; if( delay_diff < 0 ) { channel_data_double[instance].delays[j][i] = - channel_data_double[instance].delays[j][i] ;} } else {channel_data_double[instance].delays[j][i] = 0;} }} } /*Update for each channel tap/**/ /* Find the longest delay in the channel (to allocate enough memory for stored chips) /**/ channel_data_double[instance].max_memory = channel_delays[nTaps-1]; for (j = 2; j <= nImpulse; j++){ if ( channel_delays[j * nTaps - 1] > channel_data_double[instance].max_memory ) channel_data_double[instance].max_memory = channel_delays[j * nTaps-1]; } /* Allocate memory for the memory storage of previous time chips /**/ channel_data_double[instance].I_prev_chips = (double*)calloc( channel_data_double[instance].max_memory, sizeof(double)); channel_data_double[instance].Q_prev_chips = (double*)calloc( channel_data_double[instance].max_memory, sizeof(double)); /* Update the static tables to keep in mind which channel instances are in use /**/ channel_alloc_list_double[instance] = INSTANCE_IN_USE; channel_index_double ++; /* If you want to check what has been updated call: channel_print(instance);/**/ return(instance); } /* -----------------------------------------------------------