block_4by4_complex.c

软件无线电的平台

/***************************************************************************
 *    block_4by4_complex.c  - Defines a variable, complex NxM MIMO block
 *                           -------------------
 *   begin                :  03/09/03
 *   authors              :  Linus Gasser
 *   emails               :  [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                Changes
 *                                -------
 * date - name - description
 * 03/07/03 - ineiti - took block_mimo to make block_complex
 * 09 Dec 2003 - chiurtu - extended to 4 by 4 system
 * 04/03/04 - ineiti - auto-detect number of rx and tx ports
 * 04/03/05 - ineiti - adjusted documentation
 *
 **************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/


/**
 * This block is used for simulations of the channel. It implements
 * a NxM MIMO-system, where N and M are <= 4.
 *  One can give the size of the block in samples as well as the
 * precision of the A/D converter.
 *  The channel-matrix h[n][m] represents the channel between the
 * tx-antenna (input) 'm' and the rx-antenna (output) 'n'.
 *  For the receiving-antenna you can give the sigma of the white noise.
 * Please be aware that the sigma is between -32767 and 32767, and compares
 * to a signal-amplitude set by the modules (usually around 10000), whereas
 * the more conventional sigma compares to a signal-amplitude of 1. 
 */

#include <stdlib.h>
#include <complex.h>
#include "spc.h"


#define DBG_LVL 0
#define RX_TX_DELAY 0
#define MAX_NO_RX 4
#define MAX_NO_TX 4

typedef struct {
  // The number of symbols of the block
  int size;      // 2560
  // The precision of the A/D converter
  int precision; // 12

  // channel entries over rows  
  complex double h[MAX_NO_RX][MAX_NO_TX]; // 0.5 + 0.5j

  // The sigma of the gaussian-noise at the receiver
  complex double sigma[MAX_NO_RX]; // 100 + 100j
}
config_t;

typedef struct {
  // The maximum number of reception antennas
  int max_no_rx;
  // The maximum number of transmission antennas
  int max_no_tx;
}
stats_t;

typedef struct {
  int size;
  int mask;
  // How many input channels
  int no_tx;
  // How many output channels
  int no_rx;
  
  // channel entries over rows  
  complex double h[MAX_NO_RX][MAX_NO_TX];
  // this is for Gaussian
  complex double sigma[MAX_NO_RX];

  // for the random-number generator
  unsigned short simrand[3];

}
private_t;


/*
 * The initialisation function, or constructor,
 * is called the first time this module is instantiated.
 */

int spc_init( swr_sdb_t *context ) {
  int i, j;
  // Begin system-definitions {
  config_t *config;
  stats_t *stats;
  MOD_INC_USE_COUNT;
  if ( sizeof( private_t ) > 0 )
    context->private_data = swr_malloc( sizeof( private_t ) );
  swr_sdb_get_config_struct( context->id, (void**)&config );
  swr_sdb_get_stats_struct( context->id, (void**)&stats );
  // } End of system-definitions

  // Tell the subsystem we don't accept resizes, but only emit them
  context->status |= SUBS_STATUS_RESIZE_BOTH;

  private->size = 0;
  // We set the standard UMTS-size for the slot
  config->size = 2560;
  config->precision = 16;

  stats->max_no_rx = MAX_NO_RX;
  stats->max_no_tx = MAX_NO_TX;

  // Channel parameters
  for(i = 0; i < MAX_NO_RX; i++){
    for(j = 0; j < MAX_NO_TX; j++){
      config->h[i][j] = 0.5 + 0.5I;
    }
  }
  
  for(j = 0; j < MAX_NO_RX; j++){
    config->sigma[j] = 100 + 100I;
  }
  

  srand( (int)get_time_usec()%100000000 );

  // initialize the random generator
  private->simrand[0]=(unsigned short)((get_time_usec()>>00)&0xffff);
  private->simrand[1]=(unsigned short)((get_time_usec()>>16)&0xffff);
  private->simrand[2]=(unsigned short)((get_time_usec()>>00)&0xffff);


  // Begin system-definitions
  swr_sdb_free_stats_struct( context->id, (void**)&stats );
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
  // End system-definitions
}


/*
 * Every time modules from the outside change the value of a configuration parameter,
 * this function is called.
 */

int spc_reconfig( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  int ch;
  swr_sdb_get_config_struct( context->id, (void**)&config );

  if ( config->size != private->size ) {
    PR_DBG( 2, "Re-setting sizes: %i, %i\n", config->size, private->size );
    private->size = config->size;

    for ( ch=0; ch<MAX_NO_TX; ch++ ){
      size_in(ch) = config->size;
    }

    for ( ch=0; ch<MAX_NO_RX; ch++ ){
      size_out(ch) = config->size;
    }
  }
  private->mask = -1 << ( 16 - config->precision );
  
  // Copy the config-parameters to the private array
  memcpy( private->sigma, config->sigma, sizeof( config->sigma ) );
  memcpy( private->h, config->h, sizeof( config->h ) );
  
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
}


int spc_configure_inputs( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  int ch;
  swr_sdb_get_config_struct( context->id, (void**)&config );

  private->no_tx = 0;
  for ( ch=0; ch<MAX_NO_TX; ch++ ){
    if ( port_in( ch ).sdb_id >= 0 ){
      private->no_tx++;
    }
  }

  PR_DBG( 4, "Got %i Tx and %i Rx ports\n",
	  private->no_tx, private->no_rx );

  // Definition - don't touch
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
}

/*
 * This is called when the input-sizes change
 * It configures the outputs
 */
int spc_configure_outputs( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  int ch;
  swr_sdb_get_config_struct( context->id, (void**)&config );

  private->no_rx = 0;
  for ( ch=0; ch<MAX_NO_RX; ch++ ){
    if ( port_out( ch ).sdb_id >= 0 ){
      private->no_rx++;
    }
  }

  PR_DBG( 4, "Got %i Tx and %i Rx ports\n",
	  private->no_tx, private->no_rx );

  // Definition - don't touch
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
}


double getSigma( swr_sdb_t *context, double amplitude ){
  double u, v, w, alpha;

  do {
    u = 2*erand48(private->simrand)-1;
    v = 2*erand48(private->simrand)-1;
    
    w = u*u + v*v;
  } while (w>=1);
  alpha = sqrt( -2 * log(w)/w);
  return alpha * u * amplitude;
}


complex double getSigmaComplex( swr_sdb_t *context, complex double amplitude ){
  
  return getSigma( context, creal( amplitude ) ) +
    getSigma( context, cimag( amplitude ) ) * I;
}


/*
 * This is the function that implements the `main method' of the class
 * Every class has got just ONE method/working-mode.
 */
int spc_pdata( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  stats_t *stats;
  SYMBOL_COMPLEX *in[MAX_NO_TX];
  SYMBOL_COMPLEX *out[MAX_NO_RX];
  int i, j, k, re, im;
  double a;
  complex double x, y;

  //  double plus_real, minus_real,	plus_imag1, plus_imag2;
  /* // Return if not all data available yet */
    for ( i=0; i<private->no_tx; i++ ){
      if ( !data_available( i ) ){
      PR_DBG( 3, "Not all data here yet. Data to port %i is missing\n",i );
      return 0;
    }
  }

  PR_DBG( 3, "Processing data: size is %i, in(%i), out(%i)\n", 
	  private->size, private->no_rx, private->no_tx );

#if DBG_LVL >= 3
  PR_DBG( 3, "h is " );
  for ( i=0; i<private->no_rx; i++ ){
    for ( j=0; j<private->no_tx; j++ ){
      PR_DBG_CL( 3, "%g+%gi   ", creal( private->h[i][j] ),
		 cimag( private->h[i][j] ) );
    }
  }
  PR_DBG_CL( 3, "\n" );

  PR_DBG( 3, "sigma is " );
  for ( i=0; i<private->no_rx; i++ ){
    PR_DBG_CL( 3, "%g+%gi   ", creal( private->sigma[i] ),
	       cimag( private->sigma[i] ) );
  }
  PR_DBG_CL( 3, "\n" );
#endif

  
  for (i = 0; i < private->no_tx; i++){
    in[i] =  buffer_in(i);
  }
  for (i = 0; i < private->no_rx; i++){
    out[i] = buffer_out(i);
  }
  
  // this is still hard coded, to omit a saturation of the channel
  a= 0.1;

  PR_DBG( 4, "A is %f, mask is %x\n", a, private->mask );
  
  if ( private->size ) {
    for ( i=0; i<private->size; i++ ) {
      for ( j=0; j<private->no_rx; j++ ) {
	y = 0;
	for ( k=0; k<private->no_tx; k++ ){
	  x = in[k][i].real + in[k][i].imag * I;
	  y += x * private->h[j][k];
	}
	y += getSigmaComplex( context, private->sigma[j] );
	y *= a;
	
	re = creal( y );
	im = cimag( y );
	
	re = max( re, -1 << 15 );
	re = min( re,  1 << 15 );
	im = max( im, -1 << 15 );
	im = min( im,  1 << 15 );
	
	out[j][i+RX_TX_DELAY].real = re & private->mask;
	out[j][i+RX_TX_DELAY].imag = im & private->mask;

      }
    }
  }
  
  swr_sdb_get_stats_struct( context->id, (void**)&stats );
  // Put your code here
  // ADD HERE
  swr_sdb_free_stats_struct( context->id, (void**)&stats );
  return(0);
}

/*
 * This is the `destructor'.
 */
int spc_finalize( swr_sdb_t *context ) {
  if ( sizeof( private_t ) > 0 )
    swr_free( private );
  MOD_DEC_USE_COUNT;
  return 0;
}


/*
 * This function is called upon "insmod" and is used to register the
 * different parts of the module to the SPM.
 */
swr_spc_id_t cdb_id;
int spc_module_init(void) {
  swr_spc_desc_t *desc;

  /**
   * Get a description-part from SPM
   * Give the following parameters:
   * Input-ports, output-ports, config-params, stat-params
   */
  desc = swr_spc_get_new_desc( MAX_NO_TX, MAX_NO_RX, 22, 2 );
  if ( !desc ) {
    PR_DBG( 0, "Can't initialise the module. This is BAD!\n" );
    return -1;
  }

  /**
   * Define the different parts of config and stats. You have to define
   * them in the same order as they appear in the structures. The names
   * can be freely chosen.
   *
   * UM_CONFIG_{INT,DOUBLE,STRING128,POINTER}( "name" );
   * UM_STATS_{INT,DOUBLE,STRING128,POINTER,BLOCK}( "name" );
   */
  UM_CONFIG_INT( "size" );
  UM_CONFIG_INT( "precision" );
  UM_CONFIG_DOUBLE_COMPLEX( "h" );
  UM_CONFIG_DOUBLE_COMPLEX( "h12" );
  UM_CONFIG_DOUBLE_COMPLEX( "h13" );
  UM_CONFIG_DOUBLE_COMPLEX( "h14" );
  UM_CONFIG_DOUBLE_COMPLEX( "h2" );
  UM_CONFIG_DOUBLE_COMPLEX( "h22" );
  UM_CONFIG_DOUBLE_COMPLEX( "h23" );
  UM_CONFIG_DOUBLE_COMPLEX( "h24" );
  UM_CONFIG_DOUBLE_COMPLEX( "h3" );
  UM_CONFIG_DOUBLE_COMPLEX( "h32" );
  UM_CONFIG_DOUBLE_COMPLEX( "h33" );
  UM_CONFIG_DOUBLE_COMPLEX( "h34" );
  UM_CONFIG_DOUBLE_COMPLEX( "h4" );
  UM_CONFIG_DOUBLE_COMPLEX( "h42" );
  UM_CONFIG_DOUBLE_COMPLEX( "h43" );
  UM_CONFIG_DOUBLE_COMPLEX( "h44" );
  UM_CONFIG_DOUBLE_COMPLEX( "sigma" );
  UM_CONFIG_DOUBLE_COMPLEX( "sigma2" );
  UM_CONFIG_DOUBLE_COMPLEX( "sigma3" );
  UM_CONFIG_DOUBLE_COMPLEX( "sigma4" );

  UM_STATS_INT( "max_no_rx" );
  UM_STATS_INT( "max_no_tx" );

  /**
   * The in- and outputs have also to be defined in the right order. First
   * port first. The additional flag is not used yet, but it will...
   *
   * UM_INPUT( SIG_{U8,SYMBOL_{S16,COMPLEX,MMX},SAMPLE_S12,S32}, 0 );
   * UM_OUTPUT( SIG_{U8,SYMBOL_{S16,COMPLEX,MMX},SAMPLE_S12,S32}, 0 );
   */
  UM_INPUT( SIG_SYMBOL_COMPLEX, 0 );
  UM_INPUT( SIG_SYMBOL_COMPLEX, 0 );
  UM_INPUT( SIG_SYMBOL_COMPLEX, 0 );
  UM_INPUT( SIG_SYMBOL_COMPLEX, 0 );

  UM_OUTPUT( SIG_SYMBOL_COMPLEX, 0 );
  UM_OUTPUT( SIG_SYMBOL_COMPLEX, 0 );
  UM_OUTPUT( SIG_SYMBOL_COMPLEX, 0 );
  UM_OUTPUT( SIG_SYMBOL_COMPLEX, 0 );


  // Initialise the callback-functions. Delete the ones you don't use
  desc->fn_init              = spc_init;
  desc->fn_reconfigure       = spc_reconfig;
  desc->fn_process_data      = spc_pdata;
  desc->fn_finalize          = spc_finalize;
  desc->fn_configure_inputs  = spc_configure_inputs;
  desc->fn_configure_outputs = spc_configure_outputs;

  // And register the module in the SPM. Change the name!
  cdb_id = swr_cdb_register_spc( &desc, "block_4by4_complex" );
  if ( cdb_id == SWR_SPM_INVALID_ID ) {
    swr_spc_free_desc( desc );
    PR_DBG( 0, "Couldn't register the module!\n" );
    return 1;
  }
  PR_DBG( 4, "Ready\n" );
  return 0;
}


/*
 * This is called upon rmmod
 */
void spc_module_exit( void ) {
  PR_DBG( 4, "Freeing id: %i\n", cdb_id );
  if ( swr_cdb_unregister_spc( cdb_id ) < 0 ) {
    PR_DBG( 0, "Still in use somewhere\n" );
  }
}


module_init( spc_module_init );
module_exit( spc_module_exit );