simul_ics.c

软件无线电的平台

/***************************************************************************
           simul_ics.c  -  simulates the strange ics-cards with 32-bit rx
                            -------------------
    begin                :  2002
    authors              :  Linus Gasser
    emails               :  [e-mail]
 ***************************************************************************/

/***************************************************************************
                                 Changes
                                 -------
 date - name - description
 02-12-11 - ineiti- begin
 03-04-04 - ineiti - added MSR_SERVER variable to connect elsewhere 
 03-05-19 - ineiti - server searches now for /tmp/$USER/server_port in order
                     to find a suitable port.
 03-11-27 - phil   - added group id for mimo
 04-01-20 - ineiti - changed for 32-bit rx
 04/03/01 - ineiti - adjusted the rx_tx_delay, using ICS_local as reference
 04/03/19 - ineiti - adjusted rx_tx_delay again, using ICS_local as reference
 04/04/08 - ineiti - adjusted rx_tx_delay to 0
 04/06/01 - ineiti - as we have only one dispatcher-thread left, ant_ch_io
                     has to iterate over all channels
 
 **************************************************************************/

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


/**
 * In order to test transmission, a client-server architecture exists
 * that allows transmission over the network.
 */

#define DBG_LVL 0
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include "system.h"
#include "debugging.h"
#include "memory.h"
#include "sdb.h"
#include "antenna.h"
#include "channel_net.h"


struct simul_net {
  int act_block;
  int act_frame;
  int gid;
  int slot_length;
  int frame_blocks;
  int socket[ MAX_ANTENNAS ];
  swr_ant_param_t *params[ MAX_ANTENNAS ];
};
struct simul_net antenna;
struct sockaddr_in servaddr;
char *hostname = "localhost";
int antennas;

/**
 * @short Looks up the hostname, which doesn't work after a udelay
 * for some strange reason...
 */
int simul_init( void ) {
  struct hostent * host;
  char *name;
  int port;
  char path_port[256];
  FILE *f_port;

  // Try to get the correct server
  if ( !( name = getenv( "MSR_SERVER" ) ) ) {
    name = hostname;
  }
  PR_DBG( 1, "Searching hostname %s\n", name );
  host = gethostbyname( name );
  if ( !host ) {
    // Fall-back to the old one
    PR_DBG( 1, "Couldn't find host %s, trying with %s\n",
            name, hostname );
    host = gethostbyname( hostname );
    if ( !host ) {
      PR_DBG( 1, "Hostname %s also failed. Aborting\n",
              hostname);
      exit(0);
    }
  }
  PR_DBG( 1, "Got hostname: %3hhu.%3hhu.%3hhu.%3hhu\n",
          host->h_addr[0], host->h_addr[1],
          host->h_addr[2], host->h_addr[3] );

  memset( &servaddr, 0, sizeof( servaddr ) );

  // Searching the port
  snprintf( path_port, 256, "/tmp/%s/server_port", getenv( "USER" ) );
  f_port = fopen( path_port, "r" );
  if ( !f_port ) {
    PR_DBG( 1, "Couldn't get server-port, trying with default\n" );
    port = SERV_PORT;
  } else {
    fscanf( f_port, "%i", &port );
    fclose( f_port );
    PR_DBG( 2, "Found port at %i\n", port );
  }

  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons( port );
  memcpy( &servaddr.sin_addr, host->h_addr, host->h_length );
  antennas = 0;
  return 0;
}


/**
 * @short in case we need to clean up something
 */
void simul_exit( void ) {}

/**
 * @short Initialises an antenna's channel
 */
int swr_ant_ch_init( swr_ant_param_t *p ) {

  if ( antennas >= MAX_ANTENNAS ){
    PR_DBG( 0, "Asking for too many antennas!!\n" );
    return -1;
  }

  antenna.params[antennas] = p;
  antenna.slot_length = 20;
  antenna.frame_blocks = p->frame_blocks;
  p->slot_length = 20;
  p->rx_tx_delay = 0;

  PR_DBG( 1, "Returning antenna-# %i\n", antennas );
  return antennas++;
}

/**
 * @short Deletes an antenna's channel
 */
void swr_ant_ch_free( int nbr_ant ) {
  close( antenna.socket[ nbr_ant ] );
  antennas--;
}

/**
 * @short Starts the channel
 */
void swr_ant_ch_start( void ) {
  int nbr_ant;
  int sockfd,ret;
  connect_t conn;
  conn.gid=-1;  
  PR_DBG( 1, "Starting %i antennas\n", antennas );
  for ( nbr_ant=0; nbr_ant<antennas; nbr_ant++ ){
    sockfd = socket( AF_INET, SOCK_STREAM, 0 );
    ret = connect( sockfd, (struct sockaddr *) &servaddr, sizeof( servaddr ) );
    
    if (ret == 0) {
      PR_DBG( 2, "Connected to %s\n", hostname );
    } else {
      PR_DBG( 0, "Cannot connect to server\n");
      return;
    }
    
    // setup RF_PARMS
    conn.indicator = INDICATOR_ID;
    conn.total_channels = antennas;
    write( sockfd, &conn, sizeof( connect_t ) );
    // read the gid back from server
    read( sockfd, &conn, sizeof(  connect_t ) );
    PR_DBG( 1, "Gid back from server=%i\n", conn.gid );
    antenna.socket[ nbr_ant ] = sockfd;
  }
  antenna.act_block = 0;
  antenna.act_frame = 0;
  antenna.gid = conn.gid;
  PR_DBG( 1, "Finished swr_ant_ch_start\n" );
}

/**
 * @short Stops the channel
 */
void swr_ant_ch_stop( ) {}

#define RX_INDEX(ch,i) ( ( (ch) % 2 ) * 4 + (i) + ( ( (i) / 4 ) * 4 ) )
/**
 * @short IOs the antenna
 */
int swr_ant_ch_io( int block ) {
  struct simul_net *sn;
  swr_ant_param_t *p;
  transmission_t trans;
  int pos, i;
  int b, nb_bytes;
  short int *sig_tx;
  short int *sig_rx;
  int nbr_ant;

  sn = &antenna;
  for ( nbr_ant=0; nbr_ant<antennas; nbr_ant++ ){
    if ( sn->params[nbr_ant]->frame_blocks <= 0 ){
      PR_DBG( 0, "Frame_Blocks of antenna %i <= 0\n", nbr_ant );
      return -1;
    }
  }
 
  sig_rx = swr_malloc( DAQ_DMA_BLOCK_SIZE_BYTES );
  /**
   * The parameter 'block' doesn't necessarily always increment
   * by p->slot_length. So we keep track in sn->act_block about
   * the actual transmitted block.
   */
  while ( sn->act_block != 
	  ( ( block + sn->slot_length ) % sn->frame_blocks ) ) {
    /**
     * First we have to send all four blocks, before we can receive them.
     * This is because the server can't calculate anything, before he has
     * all signals!
     */
    for ( nbr_ant=0; nbr_ant<antennas; nbr_ant++ ){

      PR_DBG( 4, "Sending block for antenna %i\n", nbr_ant );
      p = sn->params[nbr_ant];
      sig_tx = p->addr_tx;

      pos = sn->act_block * DAQ_DMA_BLOCK_SIZE_SAMPLES;
      /**
       * Send a block
       */
      PR_DBG( 4, "Sending offset %i on antenna %i\n", pos, nbr_ant );
      memcpy( trans.signal,
	      sig_tx + pos,
	      DAQ_DMA_BLOCK_SIZE_BYTES );
   
//      trans.is_complex=p->is_complex;
      PR_DBG( 4, "antenna %i is transmitting complex data yes or not:%i\n",
	      nbr_ant, trans.is_complex );
    
      trans.block_count = sn->act_block;
      trans.tx_gain = p->gain_tx;
      trans.rx_gain = p->gain_rx + 10;
      PR_DBG( 4, "gid: %i, tx_gain = %f, rx_gain = %f\n",
	      sn->gid, trans.tx_gain, trans.rx_gain );
    
      if ( ( nb_bytes = send( sn->socket[nbr_ant], &trans,
			      sizeof( transmission_t ), 0 ) ) == -1 ) {
	PR_DBG( 0, "send error: group %i sending antenna %i to socket %i\n", 
		sn->gid, nbr_ant, sn->socket[nbr_ant] );
      } else {
	PR_DBG( 4, "sent %d bytes of buffer %i\n", nb_bytes, b );
      }
    }

    for ( nbr_ant=0; nbr_ant<antennas; nbr_ant++ ){
      PR_DBG( 4, "Receiving block for antenna %i\n", nbr_ant );
      p = sn->params[nbr_ant];

      // Receive a block
      if ( recv( sn->socket[nbr_ant], sig_rx,
		 DAQ_DMA_BLOCK_SIZE_BYTES, MSG_WAITALL ) == -1) {
	PR_DBG( 0, "Receive error\n");
      } else {
	SYMBOL_COMPLEX_S32 *rx = (SYMBOL_COMPLEX_S32*)(p->addr_rx) + pos;
	rx = (SYMBOL_COMPLEX_S32*)(((unsigned long)rx) & ~0x3f);
	// Adjust the block for 32-bit reception
	for ( i=0; i<DAQ_DMA_BLOCK_SIZE_SAMPLES/2; i++ ){
	  rx[RX_INDEX(nbr_ant%2, i)].real = ((int)(sig_rx[2*i]))<<12;
	  rx[RX_INDEX(nbr_ant%2, i)].imag = ((int)(sig_rx[2*i+1]))<<12;
	  if ( i < 10 ){
	    PR_DBG_CL( 4, "(%6i,%6i)=(%6i,%6i) ", 
		       sig_rx[2*i], sig_rx[2*i+1],
		       rx[RX_INDEX(nbr_ant%2, i ) ].real, 
		       rx[RX_INDEX(nbr_ant%2, i ) ].imag );
	  }
	}
	PR_DBG_CL( 4, "\n" );
      }

    }
    sn->act_block = ( sn->act_block + 1 ) % p->frame_blocks;
    if ( !sn->act_block ) {
      sn->act_frame++;
      PR_DBG( 3, "Frame-# %3i, Frame-length: %i\n", sn->act_frame,
	      p->frame_blocks );
    }
  }
  swr_free( sig_rx );
  
  return 0;
}


/**
 * @short returns the delay between rx and tx
 */
int swr_ant_ch_reconfig( int nbr_ant ) {
  antenna.frame_blocks = antenna.params[nbr_ant]->frame_blocks;
  return 0;
}


/**
 * @short Set the RF frequency synthetiser
 */
void swr_ant_ch_set_synth( int nbr_ant, int board_indx, 
			   double rf,  int side){
}


/**
 * @short Set the RF attenutors
 */
void swr_ant_ch_set_att( int nbr_ant, int board_indx, double db_rx, 
			 double db_tx ){
}


/**
 * @short Switch the RF board to Rx or Tx modes
 */
void swr_ant_ch_tx_enable( int nbr_ant, int tx){
}

void swr_ant_ch_set_freq_diff( int nbr_ant, long int diff ){
}

module_init(simul_init);
module_exit(simul_exit);
EXPORT_SYMBOL(swr_ant_ch_init);
EXPORT_SYMBOL(swr_ant_ch_free);
EXPORT_SYMBOL(swr_ant_ch_start);
EXPORT_SYMBOL(swr_ant_ch_stop);
EXPORT_SYMBOL(swr_ant_ch_io);
EXPORT_SYMBOL(swr_ant_ch_reconfig);
EXPORT_SYMBOL(swr_ant_ch_set_synth);
EXPORT_SYMBOL(swr_ant_ch_set_att);
EXPORT_SYMBOL(swr_ant_ch_tx_enable);
EXPORT_SYMBOL(swr_ant_ch_set_freq_diff);