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 interface_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   bool set_gpio_ddr(uint16_t value, uint16_t mask);
  85   bool set_gpio_sels(std::string sels);
  86   bool write_gpio(uint16_t value, uint16_t mask);
  87   %rename(_real_read_gpio) read_gpio;
  88   bool read_gpio(uint16_t *value);
  89   bool enable_gpio_streaming(int enable);
  90 };
  91
  92 // ----------------------------------------------------------------
  93
  94 GR_SWIG_BLOCK_MAGIC(usrp2,source_32fc)
  95
  96 usrp2_source_32fc_sptr
  97 usrp2_make_source_32fc(const std::string ifc="eth0",
  98                        const std::string mac="")
  99   throw (std::runtime_error);
 100
 101 class usrp2_source_32fc : public usrp2_source_base
 102 {
 103 protected:
 104   usrp2_source_32fc(const std::string &ifc, const std::string &mac);
 105
 106 public:
 107   ~usrp2_source_32fc();
 108 };
 109
 110 // ----------------------------------------------------------------
 111
 112 GR_SWIG_BLOCK_MAGIC(usrp2,source_16sc)
 113
 114 usrp2_source_16sc_sptr
 115 usrp2_make_source_16sc(const std::string ifc="eth0",
 116                        const std::string mac="")
 117   throw (std::runtime_error);
 118
 119 class usrp2_source_16sc : public usrp2_source_base
 120 {
 121 protected:
 122   usrp2_source_16sc(const std::string &ifc, const std::string &mac);
 123
 124 public:
 125   ~usrp2_source_16sc();
 126 };
 127
 128 // ----------------------------------------------------------------
 129
 130 class usrp2_sink_base : public usrp2_base
 131 {
 132 protected:
 133   usrp2_sink_base() throw (std::runtime_error);
 134
 135 public:
 136   ~usrp2_sink_base();
 137
 138   bool set_gain(double gain);
 139   %rename(_real_set_center_freq) set_center_freq;
 140   bool set_lo_offset(double frequency);
 141   bool set_center_freq(double frequency, usrp2::tune_result *r);
 142   bool set_interp(int interp_factor);
 143   bool set_scale_iq(int scale_i, int scale_q);
 144   int interp();
 145   %rename(_real_default_tx_scale_iq) default_scale_iq;
 146   void default_scale_iq(int interp, int *scale_i, int *scale_q);
 147   %rename(_real_dac_rate) dac_rate;
 148   bool dac_rate(long *rate);
 149   double gain_min();
 150   double gain_max();
 151   double gain_db_per_step();
 152   double freq_min();
 153   double freq_max();
 154   %rename(_real_daughterboard_id) daughterboard_id;
 155   bool daughterboard_id(int *dbid);
 156   bool set_gpio_ddr(uint16_t value, uint16_t mask);
 157   bool set_gpio_sels(std::string sels);
 158   bool write_gpio(uint16_t value, uint16_t mask);
 159   %rename(_real_read_gpio) read_gpio;
 160   bool read_gpio(uint16_t *value);
 161 };
 162
 163 // ----------------------------------------------------------------
 164
 165 GR_SWIG_BLOCK_MAGIC(usrp2,sink_32fc)
 166
 167 usrp2_sink_32fc_sptr
 168 usrp2_make_sink_32fc(const std::string ifc="eth0",
 169                      const std::string mac="")
 170   throw (std::runtime_error);
 171
 172 class usrp2_sink_32fc : public usrp2_sink_base
 173 {
 174 protected:
 175   usrp2_sink_32fc(const std::string &ifc, const std::string &mac);
 176
 177 public:
 178   ~usrp2_sink_32fc();
 179 };
 180
 181 // ----------------------------------------------------------------
 182
 183 GR_SWIG_BLOCK_MAGIC(usrp2,sink_16sc)
 184
 185 usrp2_sink_16sc_sptr
 186 usrp2_make_sink_16sc(const std::string ifc="eth0",
 187                      const std::string mac="")
 188   throw (std::runtime_error);
 189
 190 class usrp2_sink_16sc : public usrp2_sink_base
 191 {
 192 protected:
 193   usrp2_sink_16sc(const std::string &ifc, const std::string &mac);
 194
 195 public:
 196   ~usrp2_sink_16sc();
 197 };
 198
 199 // ----------------------------------------------------------------
 200
 201 // some utility functions to allow Python to deal with pointers
 202 %{
 203   long *make_long_ptr() { return new long; }
 204   long deref_long_ptr(long *l) { return *l; }
 205   void free_long_ptr(long *l) { delete l; }
 206   int *make_int_ptr() { return new int; }
 207   int deref_int_ptr(int *l) { return *l; }
 208   void free_int_ptr(int *l) { delete l; }
 209   uint16_t *make_uint16_ptr() { return new uint16_t; }
 210   int deref_uint16_ptr(uint16_t *l) { return *l; }
 211   void free_uint16_ptr(uint16_t *l) { delete l; }
 212 %}
 213
 214 long *make_long_ptr();
 215 long deref_long_ptr(long *l);
 216 void free_long_ptr(long *l);
 217 int *make_int_ptr();
 218 int deref_int_ptr(int *l);
 219 void free_int_ptr(int *l);
 220 uint16_t *make_uint16_ptr();
 221 int deref_uint16_ptr(uint16_t *l);
 222 void free_uint16_ptr(uint16_t *l);
 223
 224 // create a more pythonic interface
 225 %pythoncode %{
 226
 227 def __set_center_freq(self, freq):
 228   tr = tune_result()
 229   r = self._real_set_center_freq(freq, tr)
 230   if r:
 231     return tr
 232   else:
 233     return None
 234
 235 def __fpga_master_clock_freq(self):
 236   f = make_long_ptr();
 237   r = self._real_fpga_master_clock_freq(f)
 238   if r:
 239     result = deref_long_ptr(f)
 240   else:
 241     result = None
 242   free_long_ptr(f)
 243   return result
 244
 245 def __adc_rate(self):
 246   rate = make_long_ptr();
 247   r = self._real_adc_rate(rate)
 248   if r:
 249     result = deref_long_ptr(rate)
 250   else:
 251     result = None
 252   free_long_ptr(rate)
 253   return result
 254
 255 def __dac_rate(self):
 256   rate = make_long_ptr();
 257   r = self._real_dac_rate(rate)
 258   if r:
 259     result = deref_long_ptr(rate)
 260   else:
 261     result = None
 262   free_long_ptr(rate)
 263   return result
 264
 265 def __gain_range(self):
 266   return [self.gain_min(),
 267           self.gain_max(),
 268           self.gain_db_per_step()]
 269
 270 # NOTE: USRP1 uses a length three tuple here (3rd value is 'freq step'),
 271 #       but it's not really useful.  We let an index error happen here
 272 #       to identify code using it.
 273 def __freq_range(self):
 274   return [self.freq_min(),
 275           self.freq_max()]
 276
 277 def __daughterboard_id(self):
 278   dbid = make_int_ptr()
 279   r = self._real_daughterboard_id(dbid)
 280   if r:
 281     result = deref_int_ptr(dbid)
 282   else:
 283     result = None
 284   free_int_ptr(dbid)
 285   return result
 286
 287 def __default_tx_scale_iq(self, interp):
 288   scale_i = make_int_ptr()
 289   scale_q = make_int_ptr()
 290   self._real_default_tx_scale_iq(interp, scale_i, scale_q)
 291   return (deref_int_ptr(scale_i), deref_int_ptr(scale_q))
 292
 293 def __read_gpio(self):
 294   value = make_uint16_ptr()
 295   r = self._real_read_gpio(value)
 296   if r:
 297     result = deref_uint16_ptr(value)
 298   else:
 299     result = None
 300   free_uint16_ptr(value)
 301   return result
 302
 303
 304 usrp2_source_32fc_sptr.set_center_freq = __set_center_freq
 305 usrp2_source_16sc_sptr.set_center_freq = __set_center_freq
 306 usrp2_sink_32fc_sptr.set_center_freq = __set_center_freq
 307 usrp2_sink_16sc_sptr.set_center_freq = __set_center_freq
 308
 309 usrp2_source_32fc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 310 usrp2_source_16sc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 311 usrp2_sink_32fc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 312 usrp2_sink_16sc_sptr.fpga_master_clock_freq = __fpga_master_clock_freq
 313
 314 usrp2_source_32fc_sptr.adc_rate = __adc_rate
 315 usrp2_source_16sc_sptr.adc_rate = __adc_rate
 316 usrp2_sink_32fc_sptr.dac_rate = __dac_rate
 317 usrp2_sink_16sc_sptr.dac_rate = __dac_rate
 318
 319 usrp2_source_32fc_sptr.gain_range = __gain_range
 320 usrp2_source_16sc_sptr.gain_range = __gain_range
 321 usrp2_sink_32fc_sptr.gain_range = __gain_range
 322 usrp2_sink_16sc_sptr.gain_range = __gain_range
 323
 324 usrp2_source_32fc_sptr.freq_range = __freq_range
 325 usrp2_source_16sc_sptr.freq_range = __freq_range
 326 usrp2_sink_32fc_sptr.freq_range = __freq_range
 327 usrp2_sink_16sc_sptr.freq_range = __freq_range
 328
 329 usrp2_source_32fc_sptr.daughterboard_id = __daughterboard_id
 330 usrp2_source_16sc_sptr.daughterboard_id = __daughterboard_id
 331 usrp2_sink_32fc_sptr.daughterboard_id = __daughterboard_id
 332 usrp2_sink_16sc_sptr.daughterboard_id = __daughterboard_id
 333
 334 usrp2_sink_32fc_sptr.default_scale_iq = __default_tx_scale_iq
 335 usrp2_sink_16sc_sptr.default_scale_iq = __default_tx_scale_iq
 336
 337 usrp2_source_32fc_sptr.read_gpio = __read_gpio
 338 usrp2_source_16sc_sptr.read_gpio = __read_gpio
 339 usrp2_sink_32fc_sptr.read_gpio = __read_gpio
 340 usrp2_sink_16sc_sptr.read_gpio = __read_gpio
 341
 342 %}