Changeset 9752

Show
Ignore:
Timestamp:
10/08/08 15:53:42
Author:
eb
Message:

more work-in-progress on cppdb. Made db_base abstract, some return
values changed.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/Makefile.am

    r9733 r9752  
    114114        db_dbs_rx.cc                    \ 
    115115        db_xcvr2450.cc                  \ 
    116         db_wbx.cc                       \ 
    117116        db_dtt754.cc                    \ 
    118117        db_dtt768.cc 
     118 
     119#       db_wbx.cc 
    119120 
    120121 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/db_base.cc

    r9748 r9752  
    3838 
    3939db_base::db_base(usrp_basic *usrp, int which, bool tx) 
    40 { 
    41   d_which = which; 
    42   d_tx = tx; 
    43   d_usrp = usrp; 
    44  
     40  : d_usrp(usrp), d_which(which), d_tx(tx), 
     41    d_lo_offset(0.0) 
     42{ 
    4543  if(d_tx) { 
    4644    d_slot = d_which * 2; 
    …… 
    8280// Function to bypass ADC buffers. Any board which is DC-coupled 
    8381// should bypass the buffers 
    84 void  
     82 
     83bool 
    8584db_base::bypass_adc_buffers(bool bypass) 
    8685{ 
    …… 
    8887    throw  std::runtime_error("TX Board has no adc buffers\n"); 
    8988  } 
     89 
     90  bool ok = true; 
    9091  if(d_which==0) { 
    9192     
    92     d_usrp->set_adc_buffer_bypass(0, bypass); 
    93     d_usrp->set_adc_buffer_bypass(1, bypass); 
    94   } 
    95   else { 
    96     d_usrp->set_adc_buffer_bypass(2, bypass); 
    97     d_usrp->set_adc_buffer_bypass(3, bypass); 
    98   } 
     93    ok &= d_usrp->set_adc_buffer_bypass(0, bypass); 
     94    ok &= d_usrp->set_adc_buffer_bypass(1, bypass); 
     95  } 
     96  else { 
     97    ok &= d_usrp->set_adc_buffer_bypass(2, bypass); 
     98    ok &= d_usrp->set_adc_buffer_bypass(3, bypass); 
     99  } 
     100  return ok; 
    99101} 
    100102 
    …… 
    162164} 
    163165 
    164  
    165 float  
    166 db_base::gain_min() 
    167 { 
    168   throw std::runtime_error("gain_min() called from base class\n"); 
    169 } 
    170  
    171 float  
    172 db_base::gain_max() 
    173 { 
    174   throw std::runtime_error("gain_max() called from base class\n"); 
    175 } 
    176  
    177 float  
    178 db_base::gain_db_per_step() 
    179 { 
    180   throw std::runtime_error("gain_db_per_step() called from base class\n"); 
    181 } 
    182  
    183 bool  
    184 db_base::set_gain(float gain) 
    185 { 
    186   // Set the gain. 
    187   //  
    188   // @param gain:  gain in decibels 
    189   // @returns True/False 
    190   throw std::runtime_error("set_gain() called from base class\n"); 
    191 } 
    192  
    193 bool  
    194 db_base::is_quadrature() 
    195 { 
    196   // Return True if this daughterboard does quadrature up or down conversion. 
    197   // That is, return True if this board requires both I & Q analog channels. 
    198   //  
    199   // This bit of info is useful when setting up the USRP Rx mux register. 
    200   throw std::runtime_error("is_quadrature() called from base class\n"); 
    201 } 
    202  
    203 bool  
     166bool 
    204167db_base::i_and_q_swapped() 
    205168{ 
    …… 
    217180} 
    218181 
    219 void  
     182bool 
    220183db_base::set_enable(bool on) 
    221184{ 
    222185  // For tx daughterboards, this controls the transmitter enable. 
    223 } 
    224  
    225 void  
     186 
     187  return true;  // default is nop 
     188} 
     189 
     190bool 
    226191db_base::set_auto_tr(bool on) 
    227192{ 
    …… 
    230195  // Should be overridden in subclasses that care.  This will typically 
    231196  // set the atr_mask, txval and rxval. 
    232 } 
    233  
    234 void  
     197 
     198  return true; 
     199} 
     200 
     201bool 
    235202db_base::set_lo_offset(double offset) 
    236203{ 
    237204  // Set how much LO is offset from requested frequency 
    238   //  
    239   // Should be overriden by daughterboards that care. 
    240 } 
    241  
    242 double  
    243 db_base::lo_offset() 
    244 { 
    245   // Get how much LO is offset from requested frequency 
    246   //  
    247   // Should be overriden by daughterboards that care. 
    248   return 0.0; 
    249 } 
    250  
    251 void  
     205 
     206  d_lo_offset = offset; 
     207  return true; 
     208} 
     209 
     210bool 
    252211db_base::select_rx_antenna(int which_antenna) 
    253212{ 
    254213  // Specify which antenna port to use for reception. 
    255214  // Should be overriden by daughterboards that care. 
     215 
     216  return which_antenna == 0; 
    256217} 
    257218 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/db_base.h

    r9748 r9752  
    3131#include <usrp_standard.h> 
    3232 
    33 #define NUM_DAUGHTERBOARDS 1 
    3433 
    3534class tune_result 
    …… 
    6564  std::string side_and_name(); 
    6665 
    67   void bypass_adc_buffers(bool bypass); 
     66  bool bypass_adc_buffers(bool bypass); 
    6867  bool set_atr_mask(int v); 
    6968  bool set_atr_txval(int v); 
    …… 
    7170  bool set_atr_tx_delay(int v); 
    7271  bool set_atr_rx_delay(int v); 
     72  bool set_lo_offset(double offset); 
     73  double lo_offset() { return d_lo_offset; } 
    7374 
    7475  //////////////////////////////////////////////////////// 
    7576  // derived classes should override the following methods 
    7677 
    77   virtual float gain_min(); 
    78   virtual float gain_max(); 
    79   virtual float gain_db_per_step(); 
    80   virtual double freq_min(); 
    81   virtual double freq_max(); 
    82   virtual struct freq_result_t set_freq(double target_freq); 
    83   virtual bool set_gain(float gain); 
    84   virtual bool is_quadrature(); 
     78  virtual float gain_min() = 0; 
     79  virtual float gain_max() = 0; 
     80  virtual float gain_db_per_step() = 0; 
     81  virtual double freq_min() = 0; 
     82  virtual double freq_max() = 0; 
     83  virtual struct freq_result_t set_freq(double target_freq) = 0; 
     84  virtual bool set_gain(float gain) = 0; 
     85  virtual bool is_quadrature() = 0; 
    8586  virtual bool i_and_q_swapped(); 
    8687  virtual bool spectrum_inverted(); 
    87   virtual void set_enable(bool on); 
    88   virtual void set_auto_tr(bool on); 
    89   virtual void set_lo_offset(double offset); 
    90   virtual double lo_offset(); 
    91   virtual void select_rx_antenna(int which_antenna); 
     88  virtual bool set_enable(bool on); 
     89  virtual bool set_auto_tr(bool on); 
     90  virtual bool select_rx_antenna(int which_antenna); 
    9291 
    9392  // FIXME tune shouldn't be a method of db_base 
    …… 
    104103  int           d_which; 
    105104  bool          d_tx; 
     105  int           d_slot; 
    106106  int           d_refclk_reg; 
    107   int          d_slot; 
     107  double       d_lo_offset; 
    108108}; 
    109109 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/db_boards.cc

    r9748 r9752  
    170170    break; 
    171171   
     172#if 0   // FIXME wbx doesn't compile 
    172173  case(USRP_DBID_WBX_LO_TX): 
    173174    db.push_back(db_base_sptr(new db_wbx_lo_tx(usrp, which_side))); 
    …… 
    176177    db.push_back(db_base_sptr(new db_wbx_lo_rx(usrp, which_side))); 
    177178    break; 
     179#endif 
    178180 
    179181  case(USRP_DBID_DTT754): 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/db_flexrf.cc

    r9733 r9752  
    287287} 
    288288 
    289 void 
    290 flexrf_base::set_lo_offset(double offset) 
    291 { 
    292   /* 
    293     Set amount by which LO is offset from requested tuning frequency. 
    294      
    295     @param offset: offset in Hz 
    296   */ 
    297   d_lo_offset = offset; 
    298 } 
    299  
    300 double 
    301 flexrf_base::lo_offset() 
    302 { 
    303   /* 
    304     Get amount by which LO is offset from requested tuning frequency. 
    305      
    306     @returns Offset in Hz 
    307   */ 
    308   return d_lo_offset; 
    309 } 
    310  
    311289// ---------------------------------------------------------------- 
    312290 
    …… 
    348326} 
    349327 
    350 void 
     328bool 
    351329flexrf_base_tx::set_auto_tr(bool on) 
    352330{ 
     331  bool ok = true; 
    353332  if(on) { 
    354     set_atr_mask (RX_TXN | ENABLE); 
    355     set_atr_txval(0      | ENABLE); 
    356     set_atr_rxval(RX_TXN | 0); 
     333    ok &= set_atr_mask (RX_TXN | ENABLE); 
     334    ok &= set_atr_txval(0      | ENABLE); 
     335    ok &= set_atr_rxval(RX_TXN | 0); 
    357336  } 
    358337  else { 
    359     set_atr_mask (0); 
    360     set_atr_txval(0); 
    361     set_atr_rxval(0); 
    362   } 
    363 } 
    364  
    365 void 
     338    ok &= set_atr_mask (0); 
     339    ok &= set_atr_txval(0); 
     340    ok &= set_atr_rxval(0); 
     341  } 
     342  return ok; 
     343} 
     344 
     345bool 
    366346flexrf_base_tx::set_enable(bool on) 
    367347{ 
    …… 
    378358    v = RX_TXN; 
    379359  } 
    380   d_usrp->write_io(d_which, v, mask); 
     360  return d_usrp->write_io(d_which, v, mask); 
    381361} 
    382362 
    …… 
    459439 
    460440 
    461  
    462 void 
     441bool 
    463442flexrf_base_rx::set_auto_tr(bool on) 
    464443{ 
     444  bool ok = true; 
    465445  if(on) { 
    466     set_atr_mask (ENABLE); 
    467     set_atr_txval(     0); 
    468     set_atr_rxval(ENABLE); 
     446    ok &= set_atr_mask (ENABLE); 
     447    ok &= set_atr_txval(     0); 
     448    ok &= set_atr_rxval(ENABLE); 
    469449  } 
    470450  else { 
    471     set_atr_mask (0); 
    472     set_atr_txval(0); 
    473     set_atr_rxval(0); 
    474   } 
    475 } 
    476  
    477 void 
     451    ok &= set_atr_mask (0); 
     452    ok &= set_atr_txval(0); 
     453    ok &= set_atr_rxval(0); 
     454  } 
     455  return true; 
     456} 
     457 
     458bool 
    478459flexrf_base_rx::select_rx_antenna(int which_antenna) 
    479460{ 
    …… 
    490471  } 
    491472  else { 
    492     throw std::invalid_argument("which_antenna must be either 'TX/RX' or 'RX2'\n"); 
    493   } 
    494 } 
    495  
    496 void 
     473    return false; 
     474    // throw std::invalid_argument("which_antenna must be either 'TX/RX' or 'RX2'\n"); 
     475  } 
     476  return true; 
     477} 
     478 
     479bool 
    497480flexrf_base_rx::select_rx_antenna(const std::string &which_antenna) 
    498481{ 
    …… 
    509492  } 
    510493  else { 
    511     throw std::invalid_argument("which_antenna must be either 'TX/RX' or 'RX2'\n"); 
    512   } 
     494    // throw std::invalid_argument("which_antenna must be either 'TX/RX' or 'RX2'\n"); 
     495    return false; 
     496  } 
     497  return true; 
    513498} 
    514499 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/db_flexrf.h

    r9733 r9752  
    4343  bool  set_gain(float gain); 
    4444  bool  is_quadrature(); 
    45   double lo_offset(); 
    46   void  set_lo_offset(double offset); 
    4745 
    4846protected: 
    …… 
    6563  int power_off() { return 0; } 
    6664 
    67   double d_lo_offset; 
    6865  bool d_first; 
    6966  int  d_spi_format; 
    …… 
    8380  ~flexrf_base_tx(); 
    8481 
    85   void set_auto_tr(bool on); 
    86   void set_enable(bool on); 
    87   float gain_min(); 
    88   float gain_max(); 
    89   float gain_db_per_step(); 
     82  float gain_min(); 
     83  float gain_max(); 
     84  float gain_db_per_step(); 
     85 
     86  bool set_auto_tr(bool on); 
     87  bool set_enable(bool on); 
    9088  bool set_gain(float gain); 
    9189 
    …… 
    10098  ~flexrf_base_rx(); 
    10199     
    102   void set_auto_tr(bool on); 
    103   void select_rx_antenna(int which_antenna); 
    104   void select_rx_antenna(const std::string &which_antenna); 
     100  bool set_auto_tr(bool on); 
     101  bool select_rx_antenna(int which_antenna); 
     102  bool select_rx_antenna(const std::string &which_antenna); 
    105103  bool set_gain(float gain); 
    106104 

  • gnuradio/branches/developers/eb/cppdb-wip/usrp/host/lib/legacy/db_wbx.h

    r9733 r9752  
    8888  ~wbx_base_tx(); 
    8989 
    90   void set_auto_tr(bool on); 
    91   void set_enable(bool on); 
    92   void set_lo_offset(double offset); 
    93   double lo_offset(); 
     90  bool set_auto_tr(bool on); 
     91  bool set_enable(bool on); 
    9492}; 
    9593 
    …… 
    104102  ~wbx_base_rx(); 
    105103   
    106   void set_auto_tr(bool on); 
    107   void select_rx_antenna(int which_antenna); 
    108   void select_rx_antenna(const std::string &which_antenna); 
     104  bool set_auto_tr(bool on); 
     105  bool select_rx_antenna(int which_antenna); 
     106  bool select_rx_antenna(const std::string &which_antenna); 
    109107  bool set_gain(float gain); 
    110   void set_lo_offset(double offset); 
    111   double lo_offset(); 
    112108  bool i_and_q_swapped(); 
    113109};