chest_send.c

This a framework to test new ideas in transmission technology. Actual development is a LDPC-coder in

/***************************************************************************
 *    chest_send.c  -  Send the channel estimation
 *
 *   begin          :  03/08/05
 *   Author         : Selvavinayagam Gunabalan
 *   emails         : [e-mail]
 ***************************************************************************/

/************************************************************************
 *                                Changelog
 *                                ---------
 * 04/03/06 - ineiti - adjusted description
 */

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/


/**
 * Midamble insertion module, MIMO incorporated!
 */

#include "spc.h"
#include "sequences.h"

#define DBG_LVL 0


typedef struct {
  // The type of the midamble inserted:
  // 0-> MCCDMA
  // 1-> Fra
  int type; // 0
  // Antenna index
  int index; // 0
  // The amplitude of the midamble
  int amplitude; // 32767
  // How many samples for the circular extension
  int circ_ext; // 8
}
config_t;

typedef struct {
}
stats_t;

typedef struct {
}
private_t;


/*
 * 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;
  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

  config->type      = 0;
  config->index     = 0;
  config->amplitude = 32767;
  config->circ_ext  = 8;

  // 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) - training_seq[ config->type ].Nt -
    config->circ_ext;

  // 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) + training_seq[ config->type ].Nt +
    config->circ_ext;

  // 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
  config_t *config;
  swr_sdb_get_config_struct( context->id, (void**)&config );


  if ( ( config->type >= TRAINING_SEQUENCES ) ||
       ( config->type < 0 ) ) {
    PR_DBG( 0, "Midamble-type %i not available, only 0..%i are valuable types.\n",
            config->type, TRAINING_SEQUENCES - 1 );
    config->type = TRAINING_SEQUENCES - 1;
  }

  if ( config->index >= training_seq[ config->type ].M ) {
    PR_DBG( 0, "Number of Antennas,%i for midamble-type %i exceeded\n",
            config->index, config->type );
    config->index = training_seq[ config->type ].M - 1;
  }
  if ( ( config->amplitude > 32767 ) ||
       ( config->amplitude < 0 ) ) {
    PR_DBG( 0, "Amplitude out of range...\n" );
    config->amplitude = 32767;
  }


  // 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;
  config_t *config;
  SYMBOL_COMPLEX *in, *out, *mid;
  int type, index, amp, data_len, circ_ext;
  int i; //counter
  short offset = 0;
  short length;

  in  =  buffer_in(0);

  out =  buffer_out(0);

  swr_sdb_get_config_struct( context->id, (void**)&config );

  type  = config->type;
  index = config->index;
  amp   = config->amplitude;
  circ_ext = config->circ_ext;

  swr_sdb_free_config_struct( context->id, (void**)&config );

  data_len = size_in(0) / 2;
  memcpy ( out, in, data_len * sizeof( SYMBOL_COMPLEX ));
  // The length has to be size_in(0) - data_len, because the input-size
  // might not be a multiple of 2.
  PR_DBG( 4, "Offset is: %i\n", data_len + training_seq[ type ].Nt + circ_ext );
  memcpy( out + data_len + training_seq[ type ].Nt + circ_ext,
          in + data_len,
          ( size_in(0) - data_len ) * sizeof( SYMBOL_COMPLEX ) );
  mid = out + data_len;

  //Every antenna sends out a shifted version
  offset = training_seq[ type ].Nt - index * training_seq [ type ].L ;
  length = 2 * training_seq[ type ].Nt;

  for ( i = 0; i < training_seq[ type ].Nt + circ_ext; i++ ) {
    int pos = ( 2*i + 2*offset + length - 2 * circ_ext ) % length;
    mid[ i ].real = amp * training_seq[ type ].sequence[ pos ];
    mid[ i ].imag = amp * training_seq[ type ].sequence[ pos + 1 ];

  }
  return(0);
}


/*
 * This is the `destructor'.
 */
int send_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 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, 4, 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( "type" );
  UM_CONFIG_INT( "index" );
  UM_CONFIG_INT( "amplitude" );
  UM_CONFIG_INT( "circ_ext" );

  /**
   * 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, "chest_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" );
  }
}