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 2, 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
  36 def pick_subdevice(u):
  37     """
  38     The user didn't specify a subdevice on the command line.
  39     If there's a daughterboard on A, select A.
  40     If there's a daughterboard on B, select B.
  41     Otherwise, select A.
  42     """
  43     if u.db[0][0].dbid() >= 0:       # dbid is < 0 if there's no d'board or a problem
  44         return (0, 0)
  45     if u.db[1][0].dbid() >= 0:
  46         return (1, 0)
  47     return (0, 0)
  48
  49 class sounder_tx:
  50     def __init__(self, loopback=False,verbose=False):
  51         self._loopback=loopback
  52         self._verbose = verbose
  53         self._u = usrp.sink_s(fpga_filename='usrp_sounder.rbf')
  54         if not self._loopback:
  55             self._subdev_spec = usrp.pick_tx_subdevice(self._u)
  56             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
  57             if self._verbose:
  58                 print "Using", self._subdev.name(), "for sounder transmitter."
  59         self._u.start()
  60
  61     def tune(self, frequency):
  62         if self._verbose:
  63             print "Setting transmitter frequency to", n2s(frequency)
  64         result = self._u.tune(0, self._subdev, frequency)
  65         if result == False:
  66             raise RuntimeError("Failed to set transmitter frequency.")
  67
  68 class sounder_rx:
  69     def __init__(self,subdev_spec=None,length=1,msgq=None,loopback=False,verbose=False,debug=False):
  70         self._subdev_spec = subdev_spec
  71         self._length = length
  72         self._msgq = msgq
  73         self._loopback = loopback
  74         self._verbose = verbose
  75         self._debug = debug
  76
  77         self._fg = gr.flow_graph()
  78         self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
  79         if not self._loopback:
  80             if self._subdev_spec == None:
  81                 self._subdev_spec = pick_subdevice(self._u)
  82             self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
  83             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
  84             if self._verbose:
  85                 print "Using", self._subdev.name(), "for sounder receiver."
  86
  87         self._vblen = gr.sizeof_gr_complex*self._length
  88         if self._debug:
  89             print "Generating impulse vectors of length", self._length, "byte length", self._vblen
  90
  91         self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
  92         self._sink = gr.message_sink(self._vblen, self._msgq, True)
  93         self._fg.connect(self._u, self._s2v, self._sink)
  94
  95     def tune(self, frequency):
  96         if self._verbose:
  97             print "Setting receiver frequency to", n2s(frequency)
  98         result = self._u.tune(0, self._subdev, frequency)
  99         if result == False:
 100             raise RuntimeError("Failed to set receiver frequency.")
 101
 102     def start(self):
 103         if self._debug:
 104             print "Starting receiver flow graph."
 105         self._fg.start()
 106
 107     def wait(self):
 108         if self._debug:
 109             print "Waiting for threads..."
 110         self._fg.wait()
 111
 112     def stop(self):
 113         if self._debug:
 114             print "Stopping receiver flow graph."
 115         self._fg.stop()
 116         self.wait()
 117         if self._debug:
 118             print "Receiver flow graph stopped."
 119
 120
 121 class sounder:
 122     def __init__(self,transmit=False,receive=False,loopback=False,rx_subdev_spec=None,
 123                  frequency=0.0,degree=10,length=1,msgq=None,verbose=False,debug=False):
 124         self._transmit = transmit
 125         self._receive = receive
 126         self._loopback = loopback
 127         self._rx_subdev_spec = rx_subdev_spec
 128         self._frequency = frequency
 129         self._degree = degree
 130         self._length = length
 131         self._msgq = msgq
 132         self._verbose = verbose
 133         self._debug = debug
 134         self._mode = 0
 135         self._u = None
 136         self._trans = None
 137         self._rcvr = None
 138         self._transmitting = False
 139         self._receiving = False
 140
 141         if self._transmit:
 142             self._trans = sounder_tx(loopback=self._loopback,verbose=self._verbose)
 143             self._u = self._trans._u
 144
 145         if self._receive:
 146             self._rcvr = sounder_rx(subdev_spec=self._rx_subdev_spec,length=self._length,
 147                                     msgq=self._msgq,loopback=self._loopback,verbose=self._verbose,
 148                                     debug=self._debug)
 149             self._u = self._rcvr._u # either receiver or transmitter object will do
 150
 151         self.set_reset(True)
 152         if self._loopback == False:
 153             self.tune(self._frequency)
 154         self.set_degree(self._degree)
 155         self.set_loopback(self._loopback)
 156         self.set_reset(False)
 157
 158     def tune(self, frequency):
 159         self._frequency = frequency
 160         if self._rcvr:
 161             self._rcvr.tune(frequency)
 162         if self._trans:
 163             self._trans.tune(frequency)
 164
 165     def set_degree(self, degree):
 166         if self._verbose:
 167             print "Setting PN code degree to", degree
 168         self._u._write_fpga_reg(FR_DEGREE, degree);
 169
 170     def _write_mode(self):
 171         if self._debug:
 172             print "Writing mode register with:", hex(self._mode)
 173         self._u._write_fpga_reg(FR_MODE, self._mode)
 174
 175     def enable_tx(self, value):
 176         if value:
 177             if self._verbose:
 178                 print "Enabling transmitter."
 179             self._mode |= bmFR_MODE_TX
 180             self._transmitting = True
 181         else:
 182             if self._verbose:
 183                 print "Disabling transmitter."
 184             self._mode &= ~bmFR_MODE_TX
 185         self._write_mode()
 186
 187     def enable_rx(self, value):
 188         if value:
 189             self._mode |= bmFR_MODE_RX
 190             self._write_mode()
 191             self._rcvr.start()
 192             self._receiving = True
 193         else:
 194             self._rcvr.stop()
 195             self._mode &= ~bmFR_MODE_RX
 196             self._write_mode()
 197             self._receiving = False
 198
 199     def set_loopback(self, value):
 200         if value:
 201             if self._verbose:
 202                 print "Enabling digital loopback."
 203             self._mode |= bmFR_MODE_LP
 204         else:
 205             if self._verbose:
 206                 print "Disabling digital loopback."
 207             self._mode &= ~bmFR_MODE_LP
 208         self._write_mode()
 209
 210     def set_reset(self, value):
 211         if value:
 212             if self._debug:
 213                 print "Asserting reset."
 214             self._mode |= bmFR_MODE_RESET
 215         else:
 216             if self._debug:
 217                 print "De-asserting reset."
 218             self._mode &= ~bmFR_MODE_RESET
 219         self._write_mode()
 220
 221     def start(self):
 222         if self._transmit:
 223             self.enable_tx(True)
 224         if self._receive:
 225             self.enable_rx(True)
 226
 227     def __del__(self):
 228         if self._transmitting:
 229             self.enable_tx(False)
 230
 231         if self._receiving:
 232             self.enable_rx(False)
 233