core/four_multi.hpp

// Copyright 2011-2013, Per Zetterberg, KTH Royal Institute of Technology
//
// 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 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef FOUR_MULTI_HPP
#define FOUR_MULTI_HPP


#include <iostream>
#include <complex>
#include <uhd/types/clock_config.hpp>
#include "gps.hpp"
#include "simulator.hpp"
#include <boost/thread/thread.hpp>

  
namespace po = boost::program_options;
using namespace boost;


enum burst_t {TX=0,RX=1,START=2,END=3,
              CALIB_TXRX=4,CALIB_RXTX=5,CALIB_RXRX=6,CALIB_TXTX=7};

#define IS_CALIB_BURST(x) (x.what>3)


struct frame_settings {
  std::vector<double> frequency;
  std::vector<double> gain_rx;
  std::vector<double> gain_tx;
  uhd::time_spec_t time;
  burst_t what;
  uint32_t small_buffer_length;
  uint32_t tx_repeats;


  frame_settings(void) { small_buffer_length=0;tx_repeats=0;};
};


class four_multi_node { 
  friend void simulate(std::vector<four_multi_node*> *nodes,channel_model *c);
  friend class super_node;
 private: friend class node_process_class;
  
 
  class usrp_thread_function_class;
  
  class udp_function_thread_class;

  public:

    void run(void);
    void run(const char* device_name, uint32_t gps_time_combined);


    four_multi_node(uint32_t buffer_length, uint32_t no_ant1, uint32_t no_ant2, bool use_external_10MHz,bool same_antenna,
                       uint32_t node_ix, std::vector<std::string> IP_addresses,
               bool simulate,uint32_t skip_ant);




   uint32_t node_ix(void){return d_node_ix;};

  void save_raw_input_on_file(uint32_t max_no_frames_to_save,std::string direcory_name="/usr/local/meas_data/");

  void dont_save_raw_input_on_file(void);

  double wait_time_for_transmissions_to_finish; 
  bool set_time_on_pps;
  
  bool skip_hw_set_during_init;

  bool use_udp;
   protected:
  
   void x2_tx(uint32_t other_node_ix ,const void *pointer_to_data, 
                uint32_t num_bytes);

   void x2_tx_udp(uint32_t other_node_ix ,const void *pointer_to_data, 
                uint32_t num_bytes);

   void x2_tx_tcp(uint32_t other_node_ix ,const void *  pointer_to_data, 
                uint32_t num_bytes);


   void x2_rx(uint32_t other_node_ix ,void  * const pointer_to_data, 
                uint32_t num_bytes);
 
   void x2_rx(std::vector<uint32_t> other_node_ixs ,
              std::vector<void  *> const pointers_to_data,  
std::vector<uint32_t> num_bytess);


   void x2_rx_tcp(uint32_t other_node_ix ,void  * const pointer_to_data, 
                uint32_t num_bytes);

   void x2_rx_udp(uint32_t other_node_ix ,void  * const pointer_to_data, 
                uint32_t num_bytes);


   void x2_rx_tcp(std::vector<uint32_t> other_node_ixs ,std::vector<void  *>
const pointers_to_data,  std::vector<uint32_t> num_bytess);


   void x2_rx_udp(std::vector<uint32_t> other_node_ixs ,std::vector<void  *> 
const pointers_to_data, 
             std::vector<uint32_t> num_bytess);


    virtual frame_settings node_process(void)=0;  
    virtual frame_settings node_init(void)=0;

    virtual void end_of_run(void)=0;
  
  
  


    uint32_t d_buffer_length, d_no_ant1, d_no_ant2, d_no_ant;
    uint32_t d_node_ix, d_skip_ant;

    bool save_input_on_file;
    std::string raw_data_dir;
    uint32_t no_rx_buffer_stored_so_far, d_max_no_frames_to_save;
    void save_logged_raw_data(void);
    void log_raw_buffer(uint32_t number_of_samples);


    void set_trx_params(frame_settings fs_new, frame_settings fs_old);
    void set_trx_params(frame_settings fs); 


    usrp_thread_function_class *m1;
    usrp_thread_function_class *m2;


  /*
    void init(uint32_t buffer_length,uint32_t no_ant1, uint32_t no_ant2 , bool use_external_10MHz,
              bool use_same_antenna,uint32_t node_ix, 
              std::vector<std::string> IP_addresses,bool simulate);
  */
    void init(uint32_t buffer_length);



    std::vector<std::string> d_IP_addresses;
    std::string d_args;
    
    double d_rate;
    static const time_t time_available_for_trigger=1; // Seconds
    static const time_t headroom_after_trigger=1; // Seconds
    

    bool d_use_external_10MHz;
    bool d_use_same_antenna;

    bool d_simulate;     //Is this a simulation run ?
    void **feedback_buffers;  // Used in simulator only
    bool *feedback_buffers_empty;  // Used in the simulator only
    uint32_t num_nodes; // Used in the simulator only
    bool never_run;  // run method never called.

    void *feedback_buffer_simulate;

    frame_settings d_old_frame_settings;

    //std::vector<const void *> d_tx_buffers;
    
    std::vector<void *> d_tx_buffers;
    std::vector<void *> d_rx_buffers;
    std::vector<void *> d_rx_storage_buffers;

   private:
  
  //void change_buffer_length(uint32_t new_buffer_length);
   four_multi_node(uint32_t no_ant1, uint32_t no_ant2, bool use_external_10MHz,bool same_antenna,
                       uint32_t node_ix, std::vector<std::string> IP_addresses,
               bool simulate,uint32_t skip_ant);

   
} ;




#endif