git.gag.com Git - debian/gnuradio/blob - gr-sounder/src/python/sounder.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 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 from gnuradio import gr, usrp
  24 from gnuradio import eng_notation
  25
  26 n2s = eng_notation.num_to_str
  27
  28 FR_MODE = usrp.FR_USER_0
  29 bmFR_MODE_RESET = 1 << 0        # bit 0: active high reset
  30 bmFR_MODE_TX    = 1 << 1        # bit 1: enable transmitter
  31 bmFR_MODE_RX    = 1 << 2        # bit 2: enable receiver
  32 bmFR_MODE_LP    = 1 << 3        # bit 3: enable digital loopback
  33
  34 FR_DEGREE = usrp.FR_USER_1
  35 FR_AMPL = usrp.FR_USER_2
  36
  37 def pick_subdevice(u):
  38     """
  39     The user didn't specify a subdevice on the command line.
  40     If there's a daughterboard on A, select A.
  41     If there's a daughterboard on B, select B.
  42     Otherwise, select A.
  43     """
  44     if u.db[0][0].dbid() >= 0:       # dbid is < 0 if there's no d'board or a problem
  45         return (0, 0)
  46     if u.db[1][0].dbid() >= 0:
  47         return (1, 0)
  48     return (0, 0)
  49
  50 class sounder_tx:
  51     def __init__(self, loopback=False,ampl=4096,verbose=False,debug=False):
  52         self._loopback=loopback
  53         self._amplitude = ampl
  54         self._verbose = verbose
  55         self._debug = debug
  56         self._u = usrp.sink_s(fpga_filename='usrp_sounder.rbf')
  57         if not self._loopback:
  58             self._subdev_spec = usrp.pick_tx_subdevice(self._u)
  59             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
  60             if self._verbose:
  61                 print "Using", self._subdev.name(), "for sounder transmitter."
  62         self.set_amplitude(ampl)
  63         if not self._loopback:
  64           self._subdev.set_lo_offset(0.0)
  65         self._u.start()
  66         if not self._loopback:
  67           self._subdev.set_enable(True)
  68
  69     def tune(self, frequency):
  70         if self._verbose:
  71             print "Setting transmitter frequency to", n2s(frequency)
  72         result = self._u.tune(0, self._subdev, frequency)
  73         if result == False:
  74             raise RuntimeError("Failed to set transmitter frequency.")
  75
  76     def set_amplitude(self, ampl):
  77         self._amplitude = ampl
  78         if self._debug:
  79             print "Writing amplitude register with:", hex(self._mode)
  80         self._u._write_fpga_reg(FR_AMPL, self._amplitude)
  81
  82 class sounder_rx:
  83     def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False):
  84         self._subdev_spec = subdev_spec
  85         self._gain = gain
  86         self._length = length
  87         self._alpha = alpha
  88         self._msgq = msgq
  89         self._loopback = loopback
  90         self._verbose = verbose
  91         self._debug = debug
  92
  93         self._tb = gr.top_block()
  94         self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
  95         if not self._loopback:
  96             if self._subdev_spec == None:
  97                 self._subdev_spec = pick_subdevice(self._u)
  98             self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
  99             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
 100             if self._verbose:
 101                 print "Using", self._subdev.name(), "for sounder receiver."
 102
 103         self.set_gain(self._gain)
 104         self._vblen = gr.sizeof_gr_complex*self._length
 105         if self._debug:
 106             print "Generating impulse vectors of length", self._length, "byte length", self._vblen
 107
 108         self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
 109         if self._verbose:
 110             print "Using smoothing alpha of", self._alpha
 111         self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length)
 112         self._sink = gr.message_sink(self._vblen, self._msgq, True)
 113         self._tb.connect(self._u, self._s2v, self._lpf, self._sink)
 114
 115     def tune(self, frequency):
 116         if self._verbose:
 117             print "Setting receiver frequency to", n2s(frequency)
 118         result = self._u.tune(0, self._subdev, frequency)
 119         if result == False:
 120             raise RuntimeError("Failed to set receiver frequency.")
 121
 122     def set_gain(self, gain):
 123         self._gain = gain
 124         if self._loopback:
 125             return
 126
 127         if self._gain is None:
 128             # if no gain was specified, use the mid-point in dB
 129             g = self._subdev.gain_range()
 130             self._gain = float(g[0]+g[1])/2
 131         if self._verbose:
 132             print "Setting receiver gain to", gain
 133         self._subdev.set_gain(self._gain)
 134
 135     def start(self):
 136         if self._debug:
 137             print "Starting receiver flow graph."
 138         self._tb.start()
 139
 140     def wait(self):
 141         if self._debug:
 142             print "Waiting for threads..."
 143         self._tb.wait()
 144
 145     def stop(self):
 146         if self._debug:
 147             print "Stopping receiver flow graph."
 148         self._tb.stop()
 149         self.wait()
 150         if self._debug:
 151             print "Receiver flow graph stopped."
 152
 153
 154 class sounder:
 155     def __init__(self,transmit=False,receive=False,loopback=False,rx_subdev_spec=None,ampl=0x1FFF,
 156                  frequency=0.0,rx_gain=None,degree=12,length=1,alpha=1.0,msgq=None,verbose=False,debug=False):
 157         self._transmit = transmit
 158         self._receive = receive
 159         self._loopback = loopback
 160         self._rx_subdev_spec = rx_subdev_spec
 161         self._frequency = frequency
 162         self._amplitude = ampl
 163         self._rx_gain = rx_gain
 164         self._degree = degree
 165         self._length = length
 166         self._alpha = alpha
 167         self._msgq = msgq
 168         self._verbose = verbose
 169         self._debug = debug
 170         self._mode = 0
 171         self._u = None
 172         self._trans = None
 173         self._rcvr = None
 174         self._transmitting = False
 175         self._receiving = False
 176
 177         if self._transmit:
 178             self._trans = sounder_tx(loopback=self._loopback,ampl=self._amplitude,
 179                                      verbose=self._verbose)
 180             self._u = self._trans._u
 181
 182         if self._receive:
 183             self._rcvr = sounder_rx(subdev_spec=self._rx_subdev_spec,length=self._length,
 184                                     gain=self._rx_gain,alpha=self._alpha,msgq=self._msgq,
 185                                     loopback=self._loopback,verbose=self._verbose,
 186                                     debug=self._debug)
 187             self._u = self._rcvr._u # either receiver or transmitter object will do
 188
 189         self.set_reset(True)
 190         if self._loopback == False:
 191             self.tune(self._frequency)
 192         self.set_degree(self._degree)
 193         self.set_loopback(self._loopback)
 194         self.set_reset(False)
 195
 196     def tune(self, frequency):
 197         self._frequency = frequency
 198         if self._rcvr:
 199             self._rcvr.tune(frequency)
 200         if self._trans:
 201             self._trans.tune(frequency)
 202
 203     def set_degree(self, degree):
 204         if self._verbose:
 205             print "Setting PN code degree to", degree
 206         self._u._write_fpga_reg(FR_DEGREE, degree);
 207
 208     def _write_mode(self):
 209         if self._debug:
 210             print "Writing mode register with:", hex(self._mode)
 211         self._u._write_fpga_reg(FR_MODE, self._mode)
 212
 213     def enable_tx(self, value):
 214         if value:
 215             if self._verbose:
 216                 print "Enabling transmitter."
 217             self._mode |= bmFR_MODE_TX
 218             self._transmitting = True
 219         else:
 220             if self._verbose:
 221                 print "Disabling transmitter."
 222             self._mode &= ~bmFR_MODE_TX
 223         self._write_mode()
 224
 225     def enable_rx(self, value):
 226         if value:
 227             self._mode |= bmFR_MODE_RX
 228             self._write_mode()
 229             self._rcvr.start()
 230             self._receiving = True
 231         else:
 232             self._rcvr.stop()
 233             self._mode &= ~bmFR_MODE_RX
 234             self._write_mode()
 235             self._receiving = False
 236
 237     def set_loopback(self, value):
 238         if value:
 239             if self._verbose:
 240                 print "Enabling digital loopback."
 241             self._mode |= bmFR_MODE_LP
 242         else:
 243             if self._verbose:
 244                 print "Disabling digital loopback."
 245             self._mode &= ~bmFR_MODE_LP
 246         self._write_mode()
 247
 248     def set_reset(self, value):
 249         if value:
 250             if self._debug:
 251                 print "Asserting reset."
 252             self._mode |= bmFR_MODE_RESET
 253         else:
 254             if self._debug:
 255                 print "De-asserting reset."
 256             self._mode &= ~bmFR_MODE_RESET
 257         self._write_mode()
 258
 259     def start(self):
 260         if self._transmit:
 261             self.enable_tx(True)
 262         if self._receive:
 263             self.enable_rx(True)
 264
 265     def __del__(self):
 266         if self._transmitting:
 267             self.enable_tx(False)
 268
 269         if self._receiving:
 270             self.enable_rx(False)
 271