simul_complex.c

软件无线电的平台

/***************************************************************************
           simul_complex.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/24 - ineiti - made a complex simulator
 
 **************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.
 *  This simulator is complex
 */

#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;
};
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( 0, "Couldn't find host %s, trying with %s\n",
            name, hostname );
    host = gethostbyname( hostname );
    if ( !host ) {
      PR_DBG( 0, "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( 0, "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( void ) {
  int sockfd,ret;
  connect_t conn;

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

  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 -1;
  }

  //setup RF_PARMS
  conn.indicator = INDICATOR_ID;
  write( sockfd, &conn, sizeof( connect_t ) );

  antenna[ antennas ].socket = sockfd;
  antenna[ antennas ].act_block = 0;
  antenna[ antennas ].act_frame = 0;

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

/**
 * @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( int blocks_per_frame ) {
  int nbr_ant;
  
  PR_DBG( 3, "Setting frame blocks to %i for %i antennas\n", blocks_per_frame, antennas );
  for ( nbr_ant=0; nbr_ant<antennas; nbr_ant++ ){
    antenna[ nbr_ant ].params.frame_blocks = blocks_per_frame;
  }
}

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

/**
 * @short IOs the antenna
 */
int swr_ant_ch_io( int nbr_ant, int block ) {
  struct simul_net *sn = &antenna[ nbr_ant ];
  swr_ant_param_t *p = &sn->params;
  transmission_t trans;
  int pos;
  int b, nb_bytes;
  short int *sig_tx = p->addr_tx;
  short int *sig_rx = p->addr_rx;

  if ( p->frame_blocks <= 0 ){
//    PR_DBG( 0, "Frame_Blocks of antenna %i <= 0\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.tx_gain = p->gain_tx;
    trans.rx_gain = p->gain_rx + 10;
    PR_DBG( 4, "tx_gain = %f, rx_gain = %f\n",
            trans.tx_gain, trans.rx_gain );

    if ( ( nb_bytes = send( sn->socket, &trans,
                            sizeof( transmission_t ), 0 ) ) == -1 ) {
      PR_DBG( 0, "send error\n");
    } 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");
    }
    //    usleep( 1 );
    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 Update frame's proprieties
 */
void swr_ant_ch_frame_params( int nbr_ant, void *rx, void *tx ) {
  antenna[ nbr_ant ].params.addr_rx = rx;
  antenna[ nbr_ant ].params.addr_tx = tx;
}


/**
 * @short Update transciever proprieties
 */
void swr_ant_ch_set_gains( int nbr_ant, double rx_gain, double tx_gain ) {
  swr_ant_ch_set_rx_gain( nbr_ant, rx_gain );
  swr_ant_ch_set_tx_gain( nbr_ant, tx_gain );
}
void swr_ant_ch_set_rx_gain( int nbr_ant, double rx_gain ) {
  PR_DBG( 3, "New rx-gain=%4f\n", rx_gain );
  antenna[ nbr_ant ].params.gain_rx = rx_gain;
}
void swr_ant_ch_set_tx_gain( int nbr_ant, double tx_gain ) {
  PR_DBG( 3, "New tx-gain=%4f\n", tx_gain );
  antenna[ nbr_ant ].params.gain_tx = tx_gain;
}


/**
 * @short get the gains
 */
double swr_ant_ch_get_rx_gain( int nbr_ant ) {
  return antenna[ nbr_ant ].params.gain_rx;
}
double swr_ant_ch_get_tx_gain( int nbr_ant ) {
  return antenna[ nbr_ant ].params.gain_tx;
}


/**
 * @short returns the delay between rx and tx
 */
int swr_ant_ch_rx_tx_delay( void ) {
  // Attn: magic number!
  return 50;
}



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_frame_params);
EXPORT_SYMBOL(swr_ant_ch_set_gains);
EXPORT_SYMBOL(swr_ant_ch_set_rx_gain);
EXPORT_SYMBOL(swr_ant_ch_set_tx_gain);
EXPORT_SYMBOL(swr_ant_ch_get_rx_gain);
EXPORT_SYMBOL(swr_ant_ch_get_tx_gain);
EXPORT_SYMBOL(swr_ant_ch_rx_tx_delay);