3 # Copyright 2007 Free Software Foundation, Inc.
5 # This file is part of GNU Radio
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)
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.
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.
23 from gnuradio import gr, usrp
24 from gnuradio import eng_notation
25 from gr import gr_threading as _threading
27 n2s = eng_notation.num_to_str
29 txp_delay = 60 # Pipeline delay to turn on transmit mixer
30 rxp_delay = 76 # Pipeline delay to turn off transmit mixer
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
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
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
67 #-----------------------------------------------------------------------
68 # Transmitter object. Uses usrp_sink, but only for a handle to the
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')
78 if self._subdev_spec == None:
79 self._subdev_spec = usrp.pick_tx_subdevice(self._u)
81 self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
82 self._subdev.set_lo_offset(0.0)
89 print "Using", self._subdev.name(), "for radar transmitter."
91 def set_ton(self, ton):
92 self._ton_ticks = 2*(int(ton*64e6)/2)-1 # Even number, then subtract 1
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)
97 def set_tsw(self, tsw):
98 self._tsw_ticks = 2*(int(tsw*64e6)/2)-1+rxp_delay # Even number, then subtract 1
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)
103 def set_tlook(self, tlook):
104 self._tlook_ticks = 2*(int(tlook*64e6)/2)-1 # Even number, then subtract 1
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)
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
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)
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)
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))
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)+")"
130 result = self._u.tune(0, self._subdev, center_freq)
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)
138 self._subdev.set_enable(True)
141 self._subdev.set_enable(False)
144 def subdev_spec(self):
145 return self._subdev_spec
147 def echo_length(self):
148 return self._tlook_ticks+1
151 del self._subdev # Avoid weak reference error
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")
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)
172 def set_echo_length(self, length):
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
179 def tune(self, frequency):
181 print "Setting receiver frequency to", n2s(frequency)
182 self._frequency = frequency
184 result = self._u.tune(0, self._subdev, frequency)
186 raise RuntimeError("Failed to set receiver frequency.")
188 def set_gain(self, 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)
197 if not self._connected:
198 self._setup_connections()
201 print "Starting receiver..."
206 print "Stopping receiver..."
210 print "Receiver stopped."
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)
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)
225 def _setup_connections(self):
226 if not self._length_set:
227 raise RuntimeError("Echo length not set.")
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)
235 print "Generating echo vectors of length", self._length, \
236 "(samples)", self._vblen, "(bytes)"
238 self._connected = True
241 def __init__(self, options, callback):
243 self._verbose = options.verbose
244 self._debug = options.debug
247 self._trans = radar_tx(options)
248 self._rcvr = radar_rx(options, callback)
250 self.set_tx_board(self._trans.subdev_spec())
251 self.set_debug(self._debug)
254 def _write_mode(self):
255 self._trans._u._write_fpga_reg(FR_RADAR_MODE, self._mode)
257 def set_reset(self, value):
259 self._mode |= bmFR_RADAR_MODE_RESET
261 self._mode &= ~bmFR_RADAR_MODE_RESET
264 def set_tx_board(self, tx_subdev_spec):
265 if tx_subdev_spec[0] == 1:
266 self._mode |= bmFR_RADAR_TXSIDE
268 self._mode &= ~bmFR_RADAR_TXSIDE
271 def set_debug(self, value):
273 self._mode |= bmFR_RADAR_DEBUG
275 self._mode &= ~bmFR_RADAR_DEBUG
278 def set_ton(self, ton):
279 self._trans.set_ton(ton)
281 def set_tsw(self, tsw):
282 self._trans.set_tsw(tsw)
284 def set_tlook(self, tlook):
285 self._trans.set_tlook(tlook)
286 self._rcvr.set_echo_length(self._trans.echo_length())
288 def set_prf(self, prf):
289 self._trans.set_prf(prf)
291 def set_amplitude(self, ampl):
292 self._trans.set_amplitude(ampl)
294 def set_freq(self, center_freq, chirp_width):
295 self._trans.set_freq(center_freq, chirp_width)
296 self._rcvr.tune(center_freq)
298 def set_atrdel(self, tx_delay=txp_delay, rx_delay=rxp_delay):
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)
304 self.set_reset(False)
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)
321 self._callback = callback
322 self._keep_running = True
326 while self._keep_running == True:
327 msg = self._msgq.delete_head()
329 self._callback(msg.to_string())