code.c

wcdma模型

/*
 | Project:     WCDMA simulation environment
 | Module:    
 | Author:      Maarit Melvasao
 | Date:        May 15, 1999
 |
 | History:
 |              June 10, 1999 Maarit Melvasalo
 |                      Double function added for matlab mex files.
 | 
 | Limitations:
 |              Code length must be in between 2^2 ... 2^8
 |              The index must be greater tahn 0 and less or equal
 |              to code length      
 |
 | 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.
 |
*/      

#include <math.h>
#include "code.h"
#include "config_wcdma.h"
#include "wcdma_simulink.h"

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif /* TRUE */


/* ------------ S T A T I C   D A T A   S T R U C T U R E S ----------- */

/* List that keeps record which code instances are used /**/
static enum instance_state code_alloc_list[MAX_CODES];

/* Total number of occupied codes /**/
static int code_count = 0;

/* General initialization flag /**/
static int general_code_init_flag = FALSE;

/* Code matirx to keep in memory the code length and 
   the index number of each code instance /**/
static code_matrix code_data[MAX_CODES];



/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_channel_init
 * 
 * Desc.:       Code initialization
 *              
 *              Checks that number of codes is accurate. 
 *              Saves the spreading code length to instance.
 *              Returns the code instance.   
 * Note:
 */
/* -------------------------------------------------------------------- */

int wcdma_code_init(int code_lenght)
{
  int i,j,instance,n_intervals;
    /*
     * If first call, initialize static data.
     */
    if (general_code_init_flag == FALSE) {
        for (i=0; i < MAX_CODES; i++) {
            code_alloc_list[i] = FREE_INSTANCE;
        } /* for */
        general_code_init_flag = TRUE;
    } /* if general_init_flag */

    /*
     * Find first free instance number.
     */
    instance = -1;
    for (i=0; i < MAX_CODES; i++) {
        if (code_alloc_list[i] == FREE_INSTANCE) {
            instance = i;
            break;
        }    }
    if (instance == -1) return(-1); /* no free instances */
    
    code_count ++;

    code_data[instance].code_len = code_lenght;
    code_alloc_list[i] =  INSTANCE_IN_USE;

   return(instance);
}

/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_ovsf_code (int instance, int code[])
 *
 * Desc.:              
 *         
 *              Finds the next available code for given code instance.
 *              Return value = index number 
  /**/
/* -------------------------------------------------------------------- */

int wcdma_ovsf_code(
		    int instance, 
		    int code[])
{
  int tmp,nCode,index ;
  code_matrix *code_tree;
  code_tree = &code_data[instance];

  /*
    Finds the next suitable code index for given code instance
    If no orthogonal codes can be found returns -1
    /**/
  tmp = wcdma_code_tree_update(instance, code_tree);
	  
  if(tmp == -1) return(-1);

  /*
       Gets the OVSF code with given length and index.
    /**/

  nCode = code_tree->code_len;
  index = code_tree->index;

  wcdma_get_ovsf_code(nCode, index, code);/**/
  
  return(code_tree->index);

}

/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_ovsf_code_double
 *
 * Desc.:       Interface function between mex-functions (matlab) and
 *              function:   wcdma_ovsf_code (int instance, int code[])
 *
 *              Return value : code index
 * Note:        Here the code is double vector not a integer.      
 *
 */
/* -------------------------------------------------------------------- */

int wcdma_ovsf_code_double(int instance, double code[])

{
  int code_tmp[MAX_SPREADING_FACTOR];
  int tmp,i,nCode;
  code_matrix *code_tree;

  /* 
     Call  wcdma_ovsf_code  with a integer code vector
  /**/ 
  
  tmp = wcdma_ovsf_code(instance, code_tmp);

  if(tmp == -1) return(-1);


  /* If the code was succesfully found return a double vector 
     /**/

  code_tree = &code_data[instance];
  nCode = code_tree->code_len;

  for (i=0; i < nCode ;i++){
    code[i] = code_tmp[i];
    }

  return(tmp);


}
/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_get_ovsf_code
 *
 * Desc.:       Gets the OVSF code for given code length and index
 *
 * Note:        Returns 0
 */
/* -------------------------------------------------------------------- */

int wcdma_get_ovsf_code(
			int nCode, 
			int index, 
			int *code)
{

    code_matrix *code_tree;
    int i, k ,l, k_max, sf, i_tmp,cur_k, a;
    int tmp[9];

    /* 
       If the index is 1 code is just 1's
       /**/
    if (index == 1 ){
      for (i = 0; i<nCode; i++){
	code[i] = 1; }
    return(0);
    }

    /* 
       If the index is nCode code is just - 1's
       /**/
    if (index == nCode ){
      for (i = 0; i<nCode; i++){
	code[i] = - 1; }
    return(0);
    }

    /* else /**/

    k_max = 0;
    sf = nCode / 2;
    i_tmp = index;
    tmp[0] = index;

    /* 
       Find the code index's in the tree above the given code 
       /**/
    while ( sf > 1) {
      k_max++;
      i_tmp = floor((i_tmp + 1 )/2);
      tmp[k_max] = i_tmp; 
      sf = sf / 2;
    }
    /* 
       Get the code for the given path in the tree
       Initial code is 1. 
       /**/
    
    code[0] = 1;


    for (k = 0; k <= k_max ; k++){
      /* 	
	 The length of the current code  /**/

      cur_k = pow(2, k );


      /* 
	 Indicator to which brach to take next 
	 /**/ 

      /*      a = 1;  
	      if((tmp[k_max - k] % 2) == 0 ) a = -1;  /**/
      a = ((tmp[k_max - k] % 2) == 0 ) ? -1 : 1;

      /*
	Add the new branch to existing code
	/**/

      for (i = 0; i < cur_k ; i++){
	code[ cur_k + i ] = a * code[ i ];
	}
    }
    return(0);
}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_get_ovsf_code_double
 * Desc.:       
 * Desc.:       Interface function between mex-functions (matlab) and
 *              function:   wcdma_get_ovsf_code ( )
 *
 *              Return value : int
 * Note:        Here the code is double vector not a integer.      
 *
 */
/* -------------------------------------------------------------------- */
int wcdma_get_ovsf_code_double(
			       int nCode, 
			       int index, 
			       double code[])
{
  int code_tmp[MAX_SPREADING_FACTOR];
  int i,tmp;

 /* 
     Call  wcdma_ovsf_code  with a integer code vector
  /**/ 
  
  tmp = wcdma_get_ovsf_code(nCode, index, code_tmp);

  /* If the code was succesfully found return a double vector 
     /**/

  for (i=0; i<nCode;i++){
    code[i] = (int) code_tmp[i];
    }/**/
 
  return(0);
}



/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_code_tree_update
 *
 * Desc.:       Finds the next suitable code index ofr given code instance
 *              and updates the code_matrix       
 *
 *              Return value = 
 *                        1 if a acceptable candidate was found
 *                        -1 if no more codes of this leght are available 
 * Note:

  /**/
/* -------------------------------------------------------------------- */
int wcdma_code_tree_update(
			   int instance, 
			   code_matrix *code_tree)
{
    int i, j, c, k, k_index, c_index, c_len, nCode, pot,p,ican;
    int small,big,k_tmp;
    int flag[MAX_SPREADING_FACTOR];

    nCode = code_tree->code_len;
    
    /*
      If this is the first coe
      /**/
    if (code_count == 1) {
      code_tree->index = nCode / 2;  
      return (1);
    }

    /* 
       Tmp vector to indicate if the index is acceptable or not
       /**/
    for (i = 0; i<nCode ; i++ ){
      flag[i] = 1;
    }
    /*
      Search through all possible index's until suitable index is found.
      Start the search from the codes in  the middle
      /**/
    for (i = nCode/2; i<nCode ; i++ ){  
      /* 
	 look for codes in the upper and in the lower branch   /**/
      for (j = 0; j < 2; j++ ){         
	ican = 1 + j * nCode + pow(-1, j) * (i + j);  /*candidate for index /**/
	/* j = 0 -> ican = nCode/2 + 1... nCode i.e. lower codes/*/
	/* j = 1 -> ican = nCode/2  .... 1 i.e. upper codes/**/
	/* ican = 1 + [8 7 9 6 10 5 11 4 12 3 13 2 14 1 15 0] /**/

	/*
	  Searches over the existing codes
	  /**/
	for (c = 0; c < MAX_CODES ; c++){  /*code_count; c++){/**/
	  if ((c != instance) && (code_alloc_list[c] == INSTANCE_IN_USE))
	    {	       
	      c_index = code_data[c].index;
	      c_len = code_data[c].code_len;

	      /* 
		 First check if the codes are on the different sides of the middle 
		 /**/

	      if (j > 0 &&  c_index > (c_len /2) ) {
	      }
	      else if ( j == 0 && c_index <= (c_len /2 ) ){
	      } /* it is ok for to use this index compared to this existing code /**/
	      
	      /* Else if  
		  the code length is same with the existing one
		  /**/  
	      else if (nCode == c_len ){   
		if( ican == c_index) {    /* if the index is already in use /**/  
		  flag[ican - 1] = 0; break;}  /* this index can not be used/**/
	      }
	      /* Else if 
		 the existing code is longer /**/
	      else if (nCode < c_len){ 
		k_tmp = 2;
		while (k_tmp * nCode < c_len) 
		  { k_tmp = k_tmp * 2; };
		if( (c_index  <=  (k_tmp * ican ) ) && ( c_index >  (k_tmp * (ican-1) ))){

		  flag[ican - 1] = 0; break; /* this index can not be used/**/
		}}
	      /* Else if
		 the existing code is shorter /**/ 	      
	      else { 
		k_tmp = 2;
		while (k_tmp * c_len < nCode) 
		  { k_tmp = k_tmp * 2; };
		if(  (ican /k_tmp + min(1,(ican % k_tmp))) ==  c_index){ 
		  flag[ican - 1] = 0; break; }  /* this index can not be used/**/
	      }
	    }  /* for-loop over the existing codes/**/
	}
	/* if 
	   ican was a suitable candidate compared to all existing codes
	   /**/
	if (flag[ican - 1 ] == 1){
	  code_tree->index = ican; 
	  return(1);
	}
      }
    }
    code_tree->index = -1 ; 
    return (-1); /*no possible code index was found/**/
}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_find_index
 *
 * Desc.:       Finds the next suitable code index for given code lengths
 *              
 *
 *              Return value = 
 *                        code index  if a acceptable candidate was found
 *                        -1 if no more codes of this leght are available 
 *
 * Note:        This is a interface function for matlab mex 
  /**/
/* -------------------------------------------------------------------- */
int wcdma_find_index( int instance) 

{
  int index,tmp ;
  code_matrix *code_tree;
  code_tree = &code_data[instance];

  /*
    Finds the next suitable code index for given code instance
    If no orthogonal codes can be found returns -1
    /**/
  tmp = wcdma_code_tree_update(instance, code_tree);
  
  if(tmp == -1) return(-1);

  /*
    Retuns the suitable index
    /**/
  return(code_tree->index);


}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_find_index
 *
 * Desc.:       Finds the next suitable code index for given code lengths
 *              
 *
 *              Return value = 
 *                        code index  if a acceptable candidate was found
 *                        -1 if no more codes of this leght are available 
 *
 * Note:        This is a interface function for matlab mex 
  /**/
/* -------------------------------------------------------------------- */
int wcdma_get_indexes( int number_of_codes,
		       double codes[],
		       double *indexes) 

{
  int index,tmp,i ;

  for (i = 0 ; i<number_of_codes; i++){ 
    tmp = wcdma_code_init((int)codes[i]);
    /*
      Finds the next suitable code index for given code instance
      If no orthogonal codes can be found returns -1
      /**/
    indexes[i] = (double)wcdma_find_index(tmp);
  }

  for (i = 0 ; i<number_of_codes; i++){ 
    tmp = wcdma_code_free(i);
  }

}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_code_print
 *
 * Desc.:       just a PRINT FUNCTION !!!!!!!!!!!  
 *
 * Note:        For testing purposes only
 */
/* -------------------------------------------------------------------- */
void code_print(int instance){
  int tmp ;
    code_matrix *code_tree;
    code_tree = &code_data[instance];
    printf("instance: %d  len: %d  index: %d \n", instance,code_tree->code_len,code_tree->index);

}


/* -------------------------------------------------------------------- */
/*
 * Function:    wcdma_code_free
 *
 * Desc.:       code clear function.
 *
 * Note:
 */
/* -------------------------------------------------------------------- */
int wcdma_code_free(int instance)
{
   
  code_alloc_list[instance] = FREE_INSTANCE;
  code_count--;

  return(0);
}