git.gag.com Git - debian/gnuradio/blob - gr-radar-mono/src/python/radar_mono.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 from gr import gr_threading as _threading
  26
  27 n2s = eng_notation.num_to_str
  28
  29 txp_delay = 60 # Pipeline delay to turn on transmit mixer
  30 rxp_delay = 76 # Pipeline delay to turn off transmit mixer
  31
  32 #-----------------------------------------------------------------------
  33 # FPGA Register Definitions
  34 #-----------------------------------------------------------------------
  35 FR_RADAR_MODE           = usrp.FR_USER_0    # Operational mode
  36 bmFR_RADAR_MODE_RESET   = 1 << 0        # bit 0: active high reset
  37 bmFR_RADAR_TXSIDE       = 1 << 1        # bit 1: use TX side A or B
  38 #bmFR_RADAR_MODE_LP      = 1 << 2       # bit 2: enable digital loopback
  39 #bmFR_RADAR_MODE_DR      = 1 << 3       # bit 3: enable on-board deramping
  40 #bmFR_RADAR_MODE_MD      = 1 << 4       # bit 4: enable echo metadata
  41 #bmFR_RADAR_MODE_CHIRPS  = 3 << 5       # bit 5,6: number of chirp center frequencies
  42 bmFR_RADAR_DEBUG        = 1 << 7        # bit 7: enable debugging mode
  43
  44 FR_RADAR_TON    = usrp.FR_USER_1        # 16-bit transmitter on time in clocks
  45 FR_RADAR_TSW    = usrp.FR_USER_2        # 16-bit transmitter switch time in clocks
  46 FR_RADAR_TLOOK  = usrp.FR_USER_3        # 16-bit receiver look time in clocks
  47 FR_RADAR_TIDLE  = usrp.FR_USER_4        # 32-bit inter-pulse idle time
  48 FR_RADAR_AMPL   = usrp.FR_USER_5        # 16-bit pulse amplitude (2s complement) into CORDIC
  49 FR_RADAR_FSTART = usrp.FR_USER_6        # 32-bit FTW for chirp start frequency
  50 FR_RADAR_FINCR  = usrp.FR_USER_7        # 32-bit FTW increment per transmit clock
  51 FR_RADAR_ATRDEL = usrp.FR_USER_8        # 16-bit TX delay in clocks, 16-bit RX delay in clocks
  52
  53 # These are for phase II development (need to renumber)
  54 #FR_RADAR_FREQ1N = usrp.FR_USER_8  # 24-bit N register for chirp #1
  55 #FR_RADAR_FREQ1R = usrp.FR_USER_9  # 24-bit R register for chirp #1
  56 #FR_RADAR_FREQ1C = usrp.FR_USER_10 # 24-bit C register for chirp #1
  57 #FR_RADAR_FREQ2N = usrp.FR_USER_11 # 24-bit N register for chirp #2
  58 #FR_RADAR_FREQ2R = usrp.FR_USER_12 # 24-bit R register for chirp #2
  59 #FR_RADAR_FREQ2C = usrp.FR_USER_13 # 24-bit C register for chirp #2
  60 #FR_RADAR_FREQ3N = usrp.FR_USER_14 # 24-bit N register for chirp #3
  61 #FR_RADAR_FREQ3R = usrp.FR_USER_15 # 24-bit R register for chirp #3
  62 #FR_RADAR_FREQ3C = usrp.FR_USER_16 # 24-bit C register for chirp #3
  63 #FR_RADAR_FREQ4N = usrp.FR_USER_17 # 24-bit N register for chirp #4
  64 #FR_RADAR_FREQ4R = usrp.FR_USER_18 # 24-bit R register for chirp #4
  65 #FR_RADAR_FREQ4C = usrp.FR_USER_19 # 24-bit C register for chirp #4
  66
  67 #-----------------------------------------------------------------------
  68 # Transmitter object.  Uses usrp_sink, but only for a handle to the
  69 # FPGA registers.
  70 #-----------------------------------------------------------------------
  71 class radar_tx(object):
  72     def __init__(self, options):
  73         self._subdev_spec = options.tx_subdev_spec
  74         self._verbose = options.verbose
  75         self._debug = options.debug
  76         self._u = usrp.sink_s(fpga_filename='usrp_radar_mono.rbf')
  77
  78         if self._subdev_spec == None:
  79             self._subdev_spec = usrp.pick_tx_subdevice(self._u)
  80
  81         self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
  82         self._subdev.set_lo_offset(0.0)
  83         self._ton_ticks = 0
  84         self._tsw_ticks = 0
  85         self._tlook_ticks = 0
  86         self._tidle_ticks = 0
  87
  88         if self._verbose:
  89             print "Using", self._subdev.name(), "for radar transmitter."
  90
  91     def set_ton(self, ton):
  92         self._ton_ticks = 2*(int(ton*64e6)/2)-1  # Even number, then subtract 1
  93         if self._verbose:
  94             print "Setting pulse on time to", ton, " sec ("+`self._ton_ticks+1`+" ticks)"
  95         self._u._write_fpga_reg(FR_RADAR_TON, self._ton_ticks)
  96
  97     def set_tsw(self, tsw):
  98         self._tsw_ticks = 2*(int(tsw*64e6)/2)-1+rxp_delay  # Even number, then subtract 1
  99         if self._verbose:
 100             print "Setting pulse switching time to", tsw, " sec ("+`self._tsw_ticks+1`+" ticks)"
 101         self._u._write_fpga_reg(FR_RADAR_TSW, self._tsw_ticks)
 102
 103     def set_tlook(self, tlook):
 104         self._tlook_ticks = 2*(int(tlook*64e6)/2)-1  # Even number, then subtract 1
 105         if self._verbose:
 106             print "Setting receiver look time to", tlook, " sec ("+`self._tlook_ticks+1`+" ticks)"
 107         self._u._write_fpga_reg(FR_RADAR_TLOOK, self._tlook_ticks)
 108
 109     def set_prf(self, prf):
 110         period = 2*int(32e6/prf)
 111         self._tidle_ticks = period-(self._ton_ticks+self._tsw_ticks+self._tlook_ticks+3)-1
 112         if self._verbose:
 113             print "Setting PRF to", prf, "Hz ("+`self._tidle_ticks+1`+" ticks idle time)"
 114         self._u._write_fpga_reg(FR_RADAR_TIDLE, self._tidle_ticks)
 115
 116     def set_amplitude(self, ampl):
 117         self._amplitude = int(ampl*9946/100.0) # CORDIC gain correction
 118         self._u._write_fpga_reg(FR_RADAR_AMPL, self._amplitude)
 119
 120     def set_freq(self, center_freq, chirp_width):
 121         self._center_freq = center_freq
 122         self._chirp_width = chirp_width
 123         self._fstart = -int((chirp_width/2)*(2**32)/32e6)
 124         self._fincr = int((chirp_width/16e6)*(2**32)/(self._ton_ticks+1))
 125
 126         if self._verbose:
 127             print "Setting transmitter center frequency to", n2s(center_freq)
 128             print "Setting chirp width to", n2s(chirp_width), "Hz "+"("+hex(self._fstart)+", "+hex(self._fincr)+")"
 129
 130         result = self._u.tune(0, self._subdev, center_freq)
 131         if result == False:
 132             raise RuntimeError("Failed to set transmitter frequency.")
 133         self._u._write_fpga_reg(FR_RADAR_FSTART, self._fstart)
 134         self._u._write_fpga_reg(FR_RADAR_FINCR, self._fincr)
 135
 136     def start(self):
 137         self._u.start()
 138         self._subdev.set_enable(True)
 139
 140     def stop(self):
 141         self._subdev.set_enable(False)
 142         self._u.stop()
 143
 144     def subdev_spec(self):
 145         return self._subdev_spec
 146
 147     def echo_length(self):
 148         return self._tlook_ticks+1
 149
 150     def __del__(self):
 151         del self._subdev # Avoid weak reference error
 152
 153 #-----------------------------------------------------------------------
 154 # Receiver object.  Uses usrp_source_c to receive echo records.
 155 #-----------------------------------------------------------------------
 156 class radar_rx(gr.top_block):
 157     def __init__(self, options, callback):
 158         gr.top_block.__init__(self, "radar_rx")
 159
 160         self._u = None
 161         self._subdev_spec = options.rx_subdev_spec
 162         self._gain = options.gain
 163         self._verbose = options.verbose
 164         self._debug = options.debug
 165         self._callback = callback
 166         self._length_set = False
 167         self._connected = False
 168         self._frequency = 0.0
 169         self._msgq = gr.msg_queue()
 170         self._watcher = _queue_watcher_thread(self._msgq, self._callback)
 171
 172     def set_echo_length(self, length):
 173         # Only call once
 174         if self._length_set is True:
 175             raise RuntimeError("Can only set echo length once.")
 176         self._length = length
 177         self._length_set = True
 178
 179     def tune(self, frequency):
 180         if self._verbose:
 181             print "Setting receiver frequency to", n2s(frequency)
 182         self._frequency = frequency
 183         if (self._u):
 184             result = self._u.tune(0, self._subdev, frequency)
 185             if result == False:
 186                 raise RuntimeError("Failed to set receiver frequency.")
 187
 188     def set_gain(self, gain):
 189         self._gain = gain
 190         if self._gain == None:
 191             # if no gain was specified, use the mid-point in dB
 192             g = self._subdev.gain_range()
 193             self._gain = float(g[0]+g[1])/2
 194         self._subdev.set_gain(self._gain)
 195
 196     def begin(self):
 197         if not self._connected:
 198             self._setup_connections()
 199
 200         if self._verbose:
 201             print "Starting receiver..."
 202         self.start()
 203
 204     def end(self):
 205         if self._verbose:
 206             print "Stopping receiver..."
 207         self.stop()
 208         self.wait()
 209         if self._verbose:
 210             print "Receiver stopped."
 211
 212     def _setup_usrp(self):
 213         self._u = usrp.source_c(fpga_filename='usrp_radar_mono.rbf')
 214         if self._subdev_spec == None:
 215             self._subdev_spec = usrp.pick_rx_subdevice(self._u)
 216         self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
 217         self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
 218
 219         if self._verbose:
 220             print "Using", self._subdev.side_and_name(), "for radar receiver."
 221             print "Setting receiver gain to", self._gain
 222         self.set_gain(self._gain)
 223         self.tune(self._frequency)
 224
 225     def _setup_connections(self):
 226         if not self._length_set:
 227             raise RuntimeError("Echo length not set.")
 228         self._setup_usrp()
 229         self._vblen = gr.sizeof_gr_complex*self._length
 230         self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
 231         self._sink = gr.message_sink(self._vblen, self._msgq, False)
 232         self.connect(self._u, self._s2v, self._sink)
 233
 234         if self._verbose:
 235             print "Generating echo vectors of length", self._length, \
 236                   "(samples)", self._vblen, "(bytes)"
 237
 238         self._connected = True
 239
 240 class radar(object):
 241     def __init__(self, options, callback):
 242
 243         self._verbose = options.verbose
 244         self._debug = options.debug
 245
 246         self._mode = 0
 247         self._trans = radar_tx(options)
 248         self._rcvr = radar_rx(options, callback)
 249         self.set_reset(True)
 250         self.set_tx_board(self._trans.subdev_spec())
 251         self.set_debug(self._debug)
 252         self.set_atrdel()
 253
 254     def _write_mode(self):
 255         self._trans._u._write_fpga_reg(FR_RADAR_MODE, self._mode)
 256
 257     def set_reset(self, value):
 258         if value:
 259             self._mode |= bmFR_RADAR_MODE_RESET
 260         else:
 261             self._mode &= ~bmFR_RADAR_MODE_RESET
 262         self._write_mode()
 263
 264     def set_tx_board(self, tx_subdev_spec):
 265         if tx_subdev_spec[0] == 1:
 266             self._mode |= bmFR_RADAR_TXSIDE
 267         else:
 268             self._mode &= ~bmFR_RADAR_TXSIDE
 269         self._write_mode()
 270
 271     def set_debug(self, value):
 272         if value:
 273             self._mode |= bmFR_RADAR_DEBUG
 274         else:
 275             self._mode &= ~bmFR_RADAR_DEBUG
 276         self._write_mode()
 277
 278     def set_ton(self, ton):
 279         self._trans.set_ton(ton)
 280
 281     def set_tsw(self, tsw):
 282         self._trans.set_tsw(tsw)
 283
 284     def set_tlook(self, tlook):
 285         self._trans.set_tlook(tlook)
 286         self._rcvr.set_echo_length(self._trans.echo_length())
 287
 288     def set_prf(self, prf):
 289         self._trans.set_prf(prf)
 290
 291     def set_amplitude(self, ampl):
 292         self._trans.set_amplitude(ampl)
 293
 294     def set_freq(self, center_freq, chirp_width):
 295         self._trans.set_freq(center_freq, chirp_width)
 296         self._rcvr.tune(center_freq)
 297
 298     def set_atrdel(self, tx_delay=txp_delay, rx_delay=rxp_delay):
 299         if self._verbose:
 300             print "Setting TX delay of", tx_delay, "clocks, RX delay of", rx_delay
 301         self._trans._u._write_fpga_reg(FR_RADAR_ATRDEL, tx_delay << 16 | rx_delay)
 302
 303     def start(self):
 304         self.set_reset(False)
 305         self._trans.start()
 306         self._rcvr.begin()
 307
 308     def stop(self):
 309         self._rcvr.end()
 310         self._trans.stop()
 311         self.set_reset(True)
 312
 313 #-----------------------------------------------------------------------
 314 # Queue watcher.  Dispatches received echos to callback.
 315 #-----------------------------------------------------------------------
 316 class _queue_watcher_thread(_threading.Thread):
 317     def __init__(self, msgq, callback):
 318         _threading.Thread.__init__(self)
 319         self.setDaemon(1)
 320         self._msgq = msgq
 321         self._callback = callback
 322         self._keep_running = True
 323         self.start()
 324
 325     def run(self):
 326         while self._keep_running == True:
 327             msg = self._msgq.delete_head()
 328             if self._callback:
 329                 self._callback(msg.to_string())
 330