ofdm_send.c

软件无线电的平台

/***************************************************************************
 *   ofdm_send.c  -  Do an OFDM
 ***************************************************************************/
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/


/**
 *  A module to compute the Fast Fourier Transform and its inverse, thus enabling
 * OFDM transmission. As the scaling of the output of a OFDM is difficult, there
 * is a manual scaling-factor that can be chosen by the programmer.
 */

#include "spc.h"
#include "ofdm_help.h"


#define DBG_LVL 4

typedef struct {
  // The total size will be 2 ^ size_pot
  int size_pot; // 8
  // Some multiplicative factor. Should be the same as in fft_rcv
  double mult; // 1
}
config_t;

typedef struct {}
stats_t;

typedef struct {
  complex_ofdm *temp,*input,*output,*w,*mul,*mul2,*fact1,*fact2;
  int nbr_of_fft;
  int size;
  int size_pot;
  double mult;
}
private_t;

/*
 * The size variable in the private_t is the actual size of the input
 * so it is (2^size_pot) *nbr_of_fft
 * The input is accepted in chunks of size length and there are nbr_of_fft 
 * such chunks. The fft is then performed on each chunk.
*/

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

int send_init( swr_sdb_t *context ) {
  // Begin system-definitions {
  config_t *config;
  stats_t *stats;
  //private_t *private;
  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

  // 2^8 is 256, so it's an fft of size 256
  config->size_pot = 8;
  config->mult = 1;
  private->temp = NULL;
  private->input=NULL;
  private->output=NULL;
  private->w=NULL;
  private->mul=NULL;
  private->mul2=NULL;
  private->fact1=NULL;
  private->fact2=NULL;
  private->size_pot=config->size_pot;
  private->size=1<<private->size_pot;
  private->nbr_of_fft=1;
  // 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
}


/*
 * To configure the inputs
 * this is called when the output-sizes change.
 */
int send_configure_inputs( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  swr_sdb_get_config_struct( context->id, (void**)&config );
  size_in(0) = ( size_out(0) / private->size ) * private->size;
  private->nbr_of_fft = size_in(0) / private->size;
  // Definition - don't touch
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
}


/*
 * To configure the outputs
 * this is called when the input-sizes change
 */
int send_configure_outputs( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  swr_sdb_get_config_struct( context->id, (void**)&config );

  size_out(0) = ( size_in(0) / private->size ) * private->size;

  private->nbr_of_fft = size_out(0) / private->size;

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


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

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

  private->mult = config->mult;
  private->size = 1 << config->size_pot;
  if ( private->temp ) {
    swr_free( private->temp );
  }
  if(private->input)
    swr_free(private->input);
  if(private->output)
    swr_free(private->output);
  if(private->w)
    swr_free(private->w);
  if(private->mul)
    swr_free(private->mul);
  if(private->mul2)
    swr_free(private->mul2);
  if(private->fact1)
    swr_free(private->fact1);
  if(private->fact2)
    swr_free(private->fact2);

  private->temp = swr_malloc( sizeof( complex_ofdm ) * private->size );
  private->input = swr_malloc( sizeof( complex_ofdm ) * private->size );
  private->output = swr_malloc( sizeof(  complex_ofdm ) * private->size );
  private->w = swr_malloc(sizeof( complex_ofdm) * private->size/2);
  private->mul = swr_malloc( sizeof( complex_ofdm ) * private->size );
  private->mul2 = swr_malloc( sizeof(complex_ofdm ) * private->size );
  private->fact1 = swr_malloc( sizeof(complex_ofdm ) * 2 );
  private->fact2 = swr_malloc( sizeof(complex_ofdm ) * 2 );

  // here we calculate all the e^(2*PI*i/size) factors and store them in w
  for(i=0;i<private->size/2;i++) {
    private->w[i].real = cos(2*M_PI*i/private->size);
    private->w[i].imag = sin(2*M_PI*i/private->size);
  }

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


/*
 * This is the function that implements the `main method' of the class
 * Every class has got just ONE method/working-mode.
 */
int send_pdata( swr_sdb_t *context ) {
  // Definition of variables - don't touch

  stats_t *stats;
  SYMBOL_COMPLEX *in, *out;
  int iteration, len;
  //double div;

  in = buffer_in(0);
  out = buffer_out(0);
  for ( iteration = 0; iteration < private->nbr_of_fft; iteration++ ) {
    // Initialize the complex-input
    for ( len = 0; len < private->size; len++ ) {
      private->input[len].imag =
        in[ iteration * private->size + len ].imag;
      private->input[len].real =
        in[ iteration * private->size + len ].real;
      //PR_DBG(0,"The input is %f, %f \n",private->input[len].real,private->input[len].imag);
    }

    // Now we have the 256 input samples in input array
    // Calculate the fft
    handle(private->size,private->size,0,private->input,private->output,private->temp,private->w,private->mul,private->mul2,1,private->fact1,private->fact2);

    // Write the complex-output to the output-buffer
    //div = 1. / private->size;
    for ( len = 0; len < private->size; len++ ) {
      out[ iteration * private->size + len ].imag =
        (short int) (private->output[len].imag / private->size * private->mult);
      out[ iteration * private->size + len ].real =
        (short int) (private->output[len].real / private->size * private->mult);
    }
  }
  emms();

  swr_sdb_get_stats_struct( context->id, (void**)&stats );
  swr_sdb_free_stats_struct( context->id, (void**)&stats );

  return(0);
}

/*
 * This is the `destructor'.
 */
int send_finalize( swr_sdb_t *context ) {
  if ( private->temp ) {
    swr_free( private->temp );
  }
  if(private->input)
    swr_free(private->input);
  if(private->output)
    swr_free(private->output);
  if(private->w)
    swr_free(private->w);
  if(private->mul)
    swr_free(private->mul);
  if(private->mul2)
    swr_free(private->mul2);
  if(private->fact1)
    swr_free(private->fact1);
  if(private->fact2)
    swr_free(private->fact2);

  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 send_id;
int send_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( 1, 1, 2, 0 );
  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_pot" );
  UM_CONFIG_DOUBLE( "mult" );
  /**
   * 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_OUTPUT( SIG_SYMBOL_COMPLEX, 0 );

  // Initialise the callback-functions. Delete the ones you don't use
  desc->fn_init              = send_init;
  desc->fn_reconfigure       = send_reconfig;
  desc->fn_process_data      = send_pdata;
  desc->fn_configure_inputs  = send_configure_inputs;
  desc->fn_configure_outputs = send_configure_outputs;
  desc->fn_finalize          = send_finalize;

  // And register the module in the SPM. Change the name!
  send_id = swr_cdb_register_spc( &desc, "ofdm_send" );
  if ( send_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 send_module_exit( void ) {
  PR_DBG( 4, "Freeing id: %i\n", send_id );
  if ( swr_cdb_unregister_spc( send_id ) < 0 ) {
    PR_DBG( 0, "Still in use somewhere\n" );
  }
}