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
  26 n2s = eng_notation.num_to_str
  27
  28 #-----------------------------------------------------------------------
  29 # FPGA Register Definitions
  30 #-----------------------------------------------------------------------
  31 FR_RADAR_MODE           = usrp.FR_USER_0    # Operational mode
  32 bmFR_RADAR_MODE_RESET   = 1 << 0        # bit 0: active high reset
  33 #bmFR_RADAR_MODE_LP     = 1 << 1        # bit 1: enable digital loopback
  34 #bmFR_RADAR_MODE_DR     = 1 << 2        # bit 2: enable on-board deramping
  35 #bmFR_RADAR_MODE_MD     = 1 << 3        # bit 3: enable echo metadata
  36 #bmFR_RADAR_MODE_CHIRPS = 3 << 4        # bit 4,5: number of chirp center frequencies
  37
  38 FR_RADAR_TON    = usrp.FR_USER_1        # 16-bit transmitter on time in clocks
  39 FR_RADAR_TSW    = usrp.FR_USER_2        # 16-bit transmitter switch time in clocks
  40 FR_RADAR_TLOOK  = usrp.FR_USER_3        # 16-bit receiver look time in clocks
  41 FR_RADAR_TIDLE  = usrp.FR_USER_4        # 32-bit inter-pulse idle time
  42 FR_RADAR_AMPL   = usrp.FR_USER_5        # 16-bit pulse amplitude (2s complement) into CORDIC
  43 FR_RADAR_FSTART = usrp.FR_USER_6        # 32-bit FTW for chirp start frequency
  44 FR_RADAR_FINCR  = usrp.FR_USER_7        # 32-bit FTW increment per transmit clock
  45
  46 # These are for phase II development
  47 #FR_RADAR_FREQ1N = usrp.FR_USER_8  # 24-bit N register for chirp #1
  48 #FR_RADAR_FREQ1R = usrp.FR_USER_9  # 24-bit R register for chirp #1
  49 #FR_RADAR_FREQ1C = usrp.FR_USER_10 # 24-bit control register for chirp #1
  50 #FR_RADAR_FREQ2N = usrp.FR_USER_11 # 24-bit N register for chirp #2
  51 #FR_RADAR_FREQ2R = usrp.FR_USER_12 # 24-bit R register for chirp #2
  52 #FR_RADAR_FREQ2C = usrp.FR_USER_13 # 24-bit control register for chirp #2
  53 #FR_RADAR_FREQ3N = usrp.FR_USER_14 # 24-bit N register for chirp #3
  54 #FR_RADAR_FREQ3R = usrp.FR_USER_15 # 24-bit R register for chirp #3
  55 #FR_RADAR_FREQ3C = usrp.FR_USER_16 # 24-bit control register for chirp #3
  56 #FR_RADAR_FREQ4N = usrp.FR_USER_17 # 24-bit N register for chirp #4
  57 #FR_RADAR_FREQ4R = usrp.FR_USER_18 # 24-bit R register for chirp #4
  58 #FR_RADAR_FREQ4C = usrp.FR_USER_19 # 24-bit control register for chirp #4
  59
  60 #-----------------------------------------------------------------------
  61 # Transmitter object.  Uses usrp_sink, but only for a handle to the
  62 # FPGA registers.
  63 #-----------------------------------------------------------------------
  64 class radar_tx:
  65     def __init__(self, verbose=False, debug=False):
  66         self._verbose = verbose
  67         self._debug = debug
  68
  69         self._u = usrp.sink_s(fpga_filename='usrp_radar_mono.rbf')
  70         self._subdev_spec = (0,0); # FPGA code only implements side A
  71         self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
  72         self._subdev.set_lo_offset(0.0)
  73         self._ton_ticks = 0
  74         self._tsw_ticks = 0
  75         self._tlook_ticks = 0
  76         self._tidle_ticks = 0
  77
  78         if self._verbose:
  79             print "Using", self._subdev.name(), "for radar transmitter."
  80
  81     def set_ton(self, ton):
  82         self._ton_ticks = 2*(int(ton*64e6)/2)-1  # Even number, then subtract 1
  83         if self._verbose:
  84             print "Setting pulse on time to", ton, " sec ("+`self._ton_ticks+1`+" ticks)"
  85         self._u._write_fpga_reg(FR_RADAR_TON, self._ton_ticks)
  86
  87     def set_tsw(self, tsw):
  88         self._tsw_ticks = 2*(int(tsw*64e6)/2)-1  # Even number, then subtract 1
  89         if self._verbose:
  90             print "Setting pulse switching time to", tsw, " sec ("+`self._tsw_ticks+1`+" ticks)"
  91         self._u._write_fpga_reg(FR_RADAR_TSW, self._tsw_ticks)
  92
  93     def set_tlook(self, tlook):
  94         self._tlook_ticks = 2*(int(tlook*64e6)/2)-1  # Even number, then subtract 1
  95         if self._verbose:
  96             print "Setting receiver look time to", tlook, " sec ("+`self._tlook_ticks+1`+" ticks)"
  97         self._u._write_fpga_reg(FR_RADAR_TLOOK, self._tlook_ticks)
  98
  99     def set_prf(self, prf):
 100         period = 2*int(32e6/prf)
 101         self._tidle_ticks = period-(self._ton_ticks+self._tsw_ticks+self._tlook_ticks+3)-1
 102         if self._verbose:
 103             print "Setting PRF to", prf, "Hz ("+`self._tidle_ticks+1`+" ticks idle time)"
 104         self._u._write_fpga_reg(FR_RADAR_TIDLE, self._tidle_ticks)
 105
 106     def set_amplitude(self, ampl):
 107         self._amplitude = int(ampl*9946/100.0) # CORDIC gain correction
 108         if self._debug:
 109             print "Writing amplitude register with:", hex(self._amplitude)
 110         self._u._write_fpga_reg(FR_RADAR_AMPL, self._amplitude)
 111
 112     def set_freq(self, center_freq, chirp_width):
 113         self._center_freq = center_freq
 114         self._chirp_width = chirp_width
 115         self._fstart = -int((chirp_width/2)*(2**32)/32e6)
 116         self._fincr = int((chirp_width/16e6)*(2**32)/(self._ton_ticks+1))
 117
 118         if self._verbose:
 119             print "Setting transmitter center frequency to", n2s(center_freq)
 120             print "Setting chirp width to", n2s(chirp_width), "Hz "+"("+hex(self._fstart)+", "+hex(self._fincr)+")"
 121
 122         result = self._u.tune(0, self._subdev, center_freq)
 123         if result == False:
 124             raise RuntimeError("Failed to set transmitter frequency.")
 125         self._u._write_fpga_reg(FR_RADAR_FSTART, self._fstart)
 126         self._u._write_fpga_reg(FR_RADAR_FINCR, self._fincr)
 127
 128     def start(self):
 129         self._u.start()
 130         self._subdev.set_enable(True)
 131
 132     def stop(self):
 133         self._subdev.set_enable(False)
 134         self._u.stop()
 135
 136 #-----------------------------------------------------------------------
 137 # Receiver object.  Uses usrp_source_c to receive echo records.
 138 # NOT IMPLEMENTED YET
 139 #-----------------------------------------------------------------------
 140 """
 141 class radar_rx:
 142     def __init__(self,gain=None,msgq=None,loopback=False,verbose=False,debug=False):
 143         self._gain = gain
 144         self._msgq = msgq
 145         self._loopback = loopback
 146         self._verbose = verbose
 147         self._debug = debug
 148
 149         self._fg = gr.flow_graph()
 150         self._u = usrp.source_c(fpga_filename='usrp_radar.rbf')
 151         if not self._loopback:
 152             self._subdev_spec = (0,0) # FPGA only implements side A
 153             self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
 154             self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
 155             if self._verbose:
 156                 print "Using", self._subdev.name(), "for radar receiver."
 157
 158         self.set_gain(self._gain)
 159
 160         # need to compute length here
 161
 162         self._vblen = gr.sizeof_gr_complex*self._length
 163         if self._debug:
 164             print "Generating echo vectors of length", self._length, "byte length", self._vblen
 165
 166         self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
 167         self._sink = gr.message_sink(self._vblen, self._msgq, True)
 168         self._fg.connect(self._u, self._s2v, self._sink)
 169
 170     def tune(self, frequency):
 171         if self._verbose:
 172             print "Setting receiver frequency to", n2s(frequency)
 173         result = self._u.tune(0, self._subdev, frequency)
 174         if result == False:
 175             raise RuntimeError("Failed to set receiver frequency.")
 176
 177     def set_gain(self, gain):
 178         self._gain = gain
 179         if self._loopback:
 180             return
 181
 182         if self._gain is None:
 183             # if no gain was specified, use the mid-point in dB
 184             g = self._subdev.gain_range()
 185             self._gain = float(g[0]+g[1])/2
 186         if self._verbose:
 187             print "Setting receiver gain to", gain
 188         self._subdev.set_gain(self._gain)
 189
 190     def start(self):
 191         if self._debug:
 192             print "Starting receiver flow graph."
 193         self._fg.start()
 194
 195     def wait(self):
 196         if self._debug:
 197             print "Waiting for threads..."
 198         self._fg.wait()
 199
 200     def stop(self):
 201         if self._debug:
 202             print "Stopping receiver flow graph."
 203         self._fg.stop()
 204         self.wait()
 205         if self._debug:
 206             print "Receiver flow graph stopped."
 207 """
 208
 209 class radar:
 210     def __init__(self,msgq=None,verbose=False,debug=False):
 211         self._msgq = msgq
 212         self._verbose = verbose
 213         self._debug = debug
 214
 215         self._mode = 0
 216         self._trans = radar_tx(verbose=self._verbose, debug=self._debug)
 217         self.set_reset(True)
 218
 219     def _write_mode(self):
 220         if self._debug:
 221             print "Writing mode register with:", hex(self._mode)
 222         self._trans._u._write_fpga_reg(FR_RADAR_MODE, self._mode)
 223
 224     def set_reset(self, value):
 225         if value:
 226             if self._debug:
 227                 print "Asserting reset."
 228             self._mode |= bmFR_RADAR_MODE_RESET
 229         else:
 230             if self._debug:
 231                 print "De-asserting reset."
 232             self._mode &= ~bmFR_RADAR_MODE_RESET
 233         self._write_mode()
 234
 235     """
 236     def set_loopback(self, value):
 237         if value:
 238             if self._verbose:
 239                 print "Enabling digital loopback."
 240             self._mode |= bmFR_RADAR_MODE_LP
 241         else:
 242             if self._verbose:
 243                 print "Disabling digital loopback."
 244             self._mode &= ~bmFR_RADAR_MODE_LP
 245         self._write_mode()
 246     """
 247
 248     def set_ton(self, ton):
 249         self._trans.set_ton(ton)
 250
 251     def set_tsw(self, tsw):
 252         self._trans.set_tsw(tsw)
 253
 254     def set_tlook(self, tlook):
 255         self._trans.set_tlook(tlook)
 256
 257     def set_prf(self, prf):
 258         self._trans.set_prf(prf)
 259
 260     def set_amplitude(self, ampl):
 261         self._trans.set_amplitude(ampl)
 262
 263     def set_freq(self, center_freq, chirp_width):
 264         self._trans.set_freq(center_freq, chirp_width)
 265         # set receiver center frequency
 266
 267     def start(self):
 268         self._trans.start()
 269         self.set_reset(False)
 270
 271     def stop(self):
 272         self.set_reset(True)
 273         self._trans.stop()
 274
 275     def __del__(self):
 276         self.stop()