test_data_send.c

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

/***************************************************************************
 *    test_data_send.c  -  Sends out two identical streams
 *                           -------------------
 *   begin                :  2003
 *   authors              :  ineiti
 *   emails               :  [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                Changes
 *                                -------
 * date - name - description
 * 03/02/06 - ineiti - begin
 * 04/03/06 - ineiti - adjusted description
 * 04/03/06 - ineiti - only copy data to existing outputs
 *
 **************************************************************************/

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


/**
 *  Usually you'll want to connect a random_u8 with this module, so that
 * it outputs two streams of random data. But you can also put your own
 * test-data in front of this module.
 *  One of the outputs has to be connected to the chain to be tested, while
 * the other output can be connected directly to the test_data_rcv, at least
 * in a SRadio/Test-case where you have access to this module.
 */

#include "spc.h"
#define DBG_LVL 0


typedef struct {}
config_t;

typedef struct {
  // Total number of bytes received. The amount of sent bytes is twice
  // as much.
  int total;
}
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

  // Tell the subsystem that we'll change both output AND input
  context->status |= SUBS_STATUS_RESIZE_BOTH;

  stats->total = 0;

  PR_DBG( 4, "Initialised TestDataSend\n" );

  // 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.
 * Output 0 is the one that undergoes testing, while output 1
 * should go directly to the test_data_rcv.
 */
int send_configure_inputs( swr_sdb_t *context ) {

  if ( size_out(0) != size_out(1) ) {
    if ( size_out(0) && size_out(1) ) {
      PR_DBG( 1, "Output-sizes don't match: %i!=%i, %i\n",
              size_out(0), size_out(1), size_in(0) );
      if ( size_out(0) == size_in(0) ) {
        // output 1 is the new one - waiting for confirmation on
        // output 0
        PR_DBG( 2, "Don't taking port 1 as new size: %i\n", size_out(1) );
        return 0;
      } else if ( size_out(1) == size_in(0) ) {
        // output 0 is the new one - propagating to output 1
        PR_DBG( 2, "Taking port 0 as new size: %i\n", size_out(0) );
        size_out(1) = size_out(0);
      }	else {
        PR_DBG( 0, "Both output-port have changed, or input port changed. Strange\n" );
        return 0;
      }
    } else {
      PR_DBG( 3, "Output-sizes not yet equal: %i:%i\n",
              size_out(0), size_out(1));
      // Put the empty-output to the size of the connected output
      if ( size_out(0) ) {
        size_out(1) = size_out(0);
      } else {
        // This shouldn't happen, as usually output 0 has to be defined
        // first...
        PR_DBG( 2, "Waiting for output 0 to be defined\n" );
        return 0;
      }
    }
  } else {
    PR_DBG( 3, "Output-sizes match at %i\n", size_out(0) );
  }
  size_in(0) = size_out(0);
  PR_DBG( 2, "Set input-size to %i\n", size_in(0) );

  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_out(1) = size_in(0);
  PR_DBG( 2, "Set output-size to %i\n", size_out(0) );

  // 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;
  U8 *in, *out;
  int i;

  PR_DBG( 4, "Sending something with sizes: %i/%i\n",
          size_out(0), size_out(1) );
  in = buffer_in(0);

  for ( i=0; i<2; i++ ){
    if ( port_out(i).sdb_id >= 0 && size_out(i) ){
      out = buffer_out(i);
      memcpy( out, in, size_out(i) );
    }
  }

  swr_sdb_get_stats_struct( context->id, (void**)&stats );
  stats->total += size_in(0);
  swr_sdb_free_stats_struct( context->id, (void**)&stats );
  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, 2, 0, 1 );
  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_STATS_INT( "total" );

  /**
   * 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_U8, 0 );
  UM_OUTPUT( SIG_U8, 0 );
  UM_OUTPUT( SIG_U8, 0 );

  // Initialise the callback-functions. Delete the ones you don't use
  desc->fn_init              = send_init;
  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, "test_data_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" );
  }
}