simul.c

软件无线电的平台

/***************************************************************************
           test.c  -  Tcp/IP simulator for the hardware-layer
                            -------------------
    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
 
 **************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 {
  swr_ant_param_t *params;
  int act_block;
  int socket;
  int act_frame;
  int gid;
};
struct simul_net antenna[ MAX_ANTENNAS ];
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[ antennas ].params = p;
  antenna[ antennas ].params->slot_length = 20;
  antenna[ antennas ].params->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[ nbr_ant ].socket );
  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[ nbr_ant ].socket = sockfd;
    antenna[ nbr_ant ].act_block = 0;
    antenna[ nbr_ant ].act_frame = 0;
    antenna[ nbr_ant ].gid = conn.gid;
  }
  PR_DBG( 1, "Finished swr_ant_ch_start\n" );
}

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

/**
 * @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;
  int b, nb_bytes;
  short int *sig_tx;
  short int *sig_rx;
  int nbr_ant;

  for ( nbr_ant=0; nbr_ant<antennas; nbr_ant++ ){
    sn = &antenna[ nbr_ant ];
    p = sn->params;
    sig_tx = p->addr_tx;
    sig_rx = p->addr_rx;

    if ( p->frame_blocks <= 0 ){
      PR_DBG( 0, "Frame_Blocks of antenna %i <= 0\n", nbr_ant );
      return -1;
    }
  
    if ( nbr_ant >= antennas ){
      PR_DBG( 0, "Didn't initialise antenna %i yet\n", nbr_ant );
      return -1;
    }

    /**
     * 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 + p->slot_length ) % p->frame_blocks ) ) {
      pos = sn->act_block * DAQ_DMA_BLOCK_SIZE_SAMPLES;
      /**
       * Send a block
       */
      PR_DBG( 4, "Sending offset %i\n", pos );
      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;
      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, &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 );
      } else {
	PR_DBG( 4, "sent %d bytes of buffer %i\n", nb_bytes, b );
      }
    
      /**
       * Receive a block
       */
      if ( recv( sn->socket, sig_rx + pos,
		 DAQ_DMA_BLOCK_SIZE_BYTES, MSG_WAITALL ) == -1) {
	PR_DBG( 0, "Receive error\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 );
      }
    }
  }  

  return 0;
}


/**
 * @short returns the delay between rx and tx
 */
int swr_ant_ch_reconfig( int nbr_ant ) {
  return 0;
}



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);