rf.c

软件无线电的平台

/***************************************************************************
 *    rf.c  -  A simple interface for the RF-cards
 *                           -------------------
 *   begin                :  02/10/30
 *   authors              :  Linus Gasser
 *   emails               :  [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                Changes
 *                                -------
 * date - name - description
 * 04/01/01 - proud - begin
 * 04/03/06 - ineiti - cleanup: killed RF_send, as there is only one module,
 *                     and renamed the caps to lower-case letters.
 * 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.                                   *
 *                                                                         *
 ***************************************************************************/


/**
 * This is a simple interface for the RF-ICS cards. It mainly serves as
 * a placeholder for the different configuration-variables available
 * in Base/Antenna/ICS/
 */

#include "spc.h"
#include "rf.h"
#include "antenna.h"

#define DBG_LVL 0


typedef struct {
  // The tx_attenuation
  int rx_attn; // 0
  // The rx_attenuation
  int tx_attn; // 0
  // if tx = 0, we're receiving, if tx = 1, we're sending
  int tx; // 0
  // The frequency of the RF-board. It's in kHz, and between
  // 2300 and 2500
  double freq; // 2420
  // We can have low-side or high-side injection of the signal. If
  // this is 0, we're automatically trying to keep the LO out of the
  // ISM-band. If it is 1, it's low-side injection, 2 is high-side
  // injection.
  int side; // 0
}
config_t;

typedef struct {}
stats_t;

typedef struct {
  double rx_attn ;
  double tx_attn;
  int tx;
  double freq;
  int side;
}
private_t;


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

int rf_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->rx_attn = 0;
  config->tx_attn = 0;
  config->side = 0;
  config->freq = 2420;
  config->tx=0;

  // 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 rf_reconfig( swr_sdb_t *context ) {
  // Definition of variables - don't touch
  config_t *config;
  int nbr_ant=0;
  int board_indx=0;  

  PR_DBG(4,"RF_board goes reconfig\n");
  swr_sdb_get_config_struct( context->id, (void**)&config );
  if(config->freq != private->freq || 
     config->side != private->side){
    swr_ant_ch_set_synth( nbr_ant, board_indx, config->freq, 
			  config->side);
    private->freq=config->freq;
    private->side=config->side;
  }
  if(config->rx_attn != private->rx_attn || 
     config->tx_attn != private->tx_attn){
    swr_ant_set_attn( nbr_ant, config->rx_attn, 
		      config->tx_attn);
    private->rx_attn=config->rx_attn;
    private->tx_attn=config->tx_attn;
  }
 if(config->tx != private->tx ){
   swr_ant_ch_tx_enable( nbr_ant, config->tx);
   private->tx=config->tx;
 }
  
  // Definition - don't touch
  swr_sdb_free_config_struct( context->id, (void**)&config );
  return 0;
}



/**
 *  * User messages
 *   */
int rf_custom_msg( swr_sdb_t *context, swr_usr_msg_t *data, swr_msgq ret ) {

  return 0;
}


/*
 * This is the `destructor'.
 */
int rf_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 mod_id;
int rf_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( 0, 0, 5, 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}( "name" );
   * UM_STATS_{INT,DOUBLE,STRING128}( "name" );
   */
  UM_CONFIG_INT( "gain_rx" );
  UM_CONFIG_INT( "gain_tx" );
  UM_CONFIG_INT( "tx_enable" );
  UM_CONFIG_DOUBLE( "freq");
  UM_CONFIG_INT( "side" );
  
  /**
   * 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 );
   */


  // Initialise the callback-functions. Delete the ones you don't use
  desc->fn_init              = rf_init;
  desc->fn_reconfigure       = rf_reconfig;
  desc->fn_custom_msg	     = rf_custom_msg;
  desc->fn_finalize          = rf_finalize;

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

module_init( rf_module_init );
module_exit( rf_module_exit );