git.gag.com Git - debian/gnuradio/blob - gr-usrp2/src/usrp2.i

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2008,2009 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Radio; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 %include "gnuradio.i"   // the common stuff
  24 %import <stdint.i>
  25
  26 %{
  27 #include "usrp2_source_16sc.h"
  28 #include "usrp2_source_32fc.h"
  29 #include "usrp2_sink_16sc.h"
  30 #include "usrp2_sink_32fc.h"
  31 %}
  32
  33 %include <usrp2/tune_result.h>
  34
  35 %template(uint32_t_vector) std::vector<uint32_t>;
  36
  37 // ----------------------------------------------------------------
  38
  39 class usrp2_base : public gr_sync_block
  40 {
  41 protected:
  42   usrp2_base() throw (std::runtime_error);
  43
  44 public:
  45   ~usrp2_base();
  46
  47   std::string mac_addr() const;
  48   std::string ifc_name() const;
  49   %rename(_real_fpga_master_clock_freq) fpga_master_clock_freq;
  50   bool fpga_master_clock_freq(long *freq);
  51   bool sync_to_pps();
  52   std::vector<uint32_t> peek32(uint32_t addr, uint32_t words);
  53   bool poke32(uint32_t addr, const std::vector<uint32_t> &data);
  54 };
  55
  56 // ----------------------------------------------------------------
  57
  58 class usrp2_source_base : public usrp2_base
  59 {
  60 protected:
  61   usrp2_source_base() throw (std::runtime_error);
  62
  63 public:
  64   ~usrp2_source_base();
  65
  66   bool set_gain(double gain);
  67   %rename(_real_set_center_freq) set_center_freq;
  68   bool set_lo_offset(double frequency);
  69   bool set_center_freq(double frequency, usrp2::tune_result *r);
  70   bool set_decim(int decimation_factor);
  71   bool set_scale_iq(int scale_i, int scale_q);
  72   int decim();
  73   %rename(_real_adc_rate) adc_rate;
  74   bool adc_rate(long *rate);
  75   double gain_min();
  76   double gain_max();
  77   double gain_db_per_step();
  78   double freq_min();
  79   double freq_max();
  80   %rename(_real_daughterboard_id) daughterboard_id;
  81   bool daughterboard_id(int *dbid);
  82   unsigned int overruns();
  83   unsigned int missing();
  84 };
  85
  86 // ----------------------------------------------------------------
  87
  88 GR_SWIG_BLOCK_MAGIC(usrp2,source_32fc)
  89
  90 usrp2_source_32fc_sptr
  91 usrp2_make_source_32fc(const std::string ifc="eth0",
  92                        const std::string mac="")
  93   throw (std::runtime_error);
  94
  95 class usrp2_source_32fc : public usrp2_source_base
  96 {
  97 protected:
  98   usrp2_source_32fc(const std::string &ifc, const std::string &mac);
  99
 100 public:
 101   ~usrp2_source_32fc();
 102 };
 103
 104 // ----------------------------------------------------------------
 105
 106 GR_SWIG_BLOCK_MAGIC(usrp2,source_16sc)
 107
 108 usrp2_source_16sc_sptr
 109 usrp2_make_source_16sc(const std::string ifc="eth0",
 110                        const std::string mac="")
 111   throw (std::runtime_error);
 112
 113 class usrp2_source_16sc : public usrp2_source_base
 114 {
 115 protected:
 116   usrp2_source_16sc(const std::string &ifc, const std::string &mac);
 117
 118 public:
 119   ~usrp2_source_16sc();
 120 };
 121
 122 // ----------------------------------------------------------------
 123
 124 class usrp2_sink_base : public usrp2_base
 125 {
 126 protected:
 127   usrp2_sink_base() throw (std::runtime_error);
 128
 129 public:
 130   ~usrp2_sink_base();
 131
 132   bool set_gain(double gain);
 133   %rename(_real_set_center_freq) set_center_freq;
 134   bool set_lo_offset(double frequency);
 135   bool set_center_freq(double frequency, usrp2::tune_result *r);
 136   bool set_interp(int interp_factor);
 137   bool set_scale_iq(int scale_i, int scale_q);
 138   int interp();
 139   %rename(_real_default_tx_scale_iq) default_scale_iq;
 140   void default_scale_iq(int interp, int *scale_i, int *scale_q);
 141   %rename(_real_dac_rate) dac_rate;
 142   bool dac_rate(long *rate);
 143   double gain_min();
 144   double gain_max();
 145   double gain_db_per_step();
 146   double freq_min();
 147   double freq_max();
 148   %rename(_real_daughterboard_id) daughterboard_id;
 149   bool daughterboard_id(int *dbid);
 150 };
 151
 152 // ----------------------------------------------------------------
 153
 154 GR_SWIG_BLOCK_MAGIC(usrp2,sink_32fc)
 155
 156 usrp2_sink_32fc_sptr
 157 usrp2_make_sink_32fc(const std::string ifc="eth0",
 158                      const std::string mac="")
 159   throw (std::runtime_error);
 160
 161 class usrp2_sink_32fc : public usrp2_sink_base
 162 {
 163 protected:
 164   usrp2_sink_32fc(const std::string &ifc, const std::string &mac);
 165
 166 public:
 167   ~usrp2_sink_32fc();
 168 };
 169
 170 // ----------------------------------------------------------------
 171
 172 GR_SWIG_BLOCK_MAGIC(usrp2,sink_16sc)
 173
 174 usrp2_sink_16sc_sptr
 175 usrp2_make_sink_16sc(const std::string ifc="eth0",
 176                      const std::string mac="")
 177   throw (std::runtime_error);
 178
 179 class usrp2_sink_16sc : public usrp2_sink_base
 180 {
 181 protected:
 182   usrp2_sink_16sc(const std::string &ifc, const std::string &mac);
 183
 184 public:
 185   ~usrp2_sink_16sc();
 186 };
 187
 188 // ----------------------------------------------------------------
 189
 190 // some utility functions to allow Python to deal with pointers
 191 %{
 192   long *make_long_ptr() { return (long *)malloc(sizeof(long)); }
 193   long deref_long_ptr(long *l) { return *l; }
 194   void free_long_ptr(long *l) { free(l); }
 195   int *make_int_ptr() { return (int *)malloc(sizeof(int)); }
 196   int deref_int_ptr(int *l) { return *l; }
 197   void free_int_ptr(int *l) { free(l); }
 198 %}
 199
 200 long *make_long_ptr();
 201 long deref_long_ptr(long *l);
 202 void free_long_ptr(long *l);
 203 int *make_int_ptr();
 204 int deref_int_ptr(int *l);
 205 void free_int_ptr(int *l);
 206
 207 // create a more pythonic interface
 208 %pythoncode %{
 209
 210 def __set_center_freq(self, freq):
 211   tr = tune_result()
 212   r = self._real_set_center_freq(freq, tr)
 213   if r:
 214     return tr
 215   else:
 216     return None
 217
 218 def __fpga_master_clock_freq(self):
 219   f = make_long_ptr();
 220   r = self._real_fpga_master_clock_freq(f)
 221   if r:
 222     result = deref_long_ptr(f)
 223   else:
 224     result = None
 225   free_long_ptr(f)
 226   return result
 227
 228 def __adc_rate(self):
 229   rate = make_long_ptr();
 230   r = self._real_adc_rate(rate)
 231   if r:
 232     result = deref_long_ptr(rate)
 233   else:
 234     result = None
 235   free_long_ptr(rate)
 236   return result
 237
 238 def __dac_rate(self):
 239   rate = make_long_ptr();
 240   r = self._real_dac_rate(rate)
 241   if r:
 242     result = deref_long_ptr(rate)
 243   else:
 244     result = None
 245   free_long_ptr(rate)
 246   return result
 247
 248 def __gain_range(self):
 249   return [self.gain_min(),
 250           self.gain_max(),
 251           self.gain_db_per_step()]
 252
 253 # NOTE: USRP1 uses a length three tuple here (3rd value is 'freq step'),
 254 #       but it's not really useful.  We let an index error happen here
 255 #       to identify code using it.
 256 def __freq_range(self):
 257   return [self.freq_min(),
 258           self.freq_max()]
 259
 260 def __daughterboard_id(self):
 261   dbid = make_int_ptr()
 262   r = self._real_daughterboard_id(dbid)
 263   if r:
 264     result = deref_int_ptr(dbid)
 265   else:
 266     result = None
 267   free_int_ptr(dbid)
 268   return result
 269
 270 def __default_tx_scale_iq(self, interp):
 271   scale_i = make_int_ptr()
 272   scale_q = make_int_ptr()
 273   self._real_default_tx_scale_iq(interp, scale_i, scale_q)
 274   return (deref_int_ptr(scale_i), deref_int_ptr(scale_q))
 275
 276 usrp2_source_32fc_sptr.set_center_freq = __set_center_freq
 277 usrp2_source_16sc_sptr.set_center_freq = __set_center_freq
 278 usrp2_sink_32fc_sptr.set_center_freq = __set_center_freq
 279 usrp2_sink_16sc_sptr.set_center_freq = __set_center_freq
 280
 281 usrp2_source_32fc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 282 usrp2_source_16sc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 283 usrp2_sink_32fc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 284 usrp2_sink_16sc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 285
 286 usrp2_source_32fc_sptr.adc_rate = __adc_rate
 287 usrp2_source_16sc_sptr.adc_rate = __adc_rate
 288 usrp2_sink_32fc_sptr.dac_rate = __dac_rate
 289 usrp2_sink_16sc_sptr.dac_rate = __dac_rate
 290
 291 usrp2_source_32fc_sptr.gain_range = __gain_range
 292 usrp2_source_16sc_sptr.gain_range = __gain_range
 293 usrp2_sink_32fc_sptr.gain_range = __gain_range
 294 usrp2_sink_16sc_sptr.gain_range = __gain_range
 295
 296 usrp2_source_32fc_sptr.freq_range = __freq_range
 297 usrp2_source_16sc_sptr.freq_range = __freq_range
 298 usrp2_sink_32fc_sptr.freq_range = __freq_range
 299 usrp2_sink_16sc_sptr.freq_range = __freq_range
 300
 301 usrp2_source_32fc_sptr.daughterboard_id = __daughterboard_id
 302 usrp2_source_16sc_sptr.daughterboard_id = __daughterboard_id
 303 usrp2_sink_32fc_sptr.daughterboard_id = __daughterboard_id
 304 usrp2_sink_16sc_sptr.daughterboard_id = __daughterboard_id
 305
 306 usrp2_sink_32fc_sptr.default_scale_iq = __default_tx_scale_iq
 307 usrp2_sink_16sc_sptr.default_scale_iq = __default_tx_scale_iq
 308
 309 %}