#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
+# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
from gnuradio import gr, usrp
from gnuradio import eng_notation
+from gr import gr_threading as _threading
n2s = eng_notation.num_to_str
#-----------------------------------------------------------------------
FR_RADAR_MODE = usrp.FR_USER_0 # Operational mode
bmFR_RADAR_MODE_RESET = 1 << 0 # bit 0: active high reset
-bmFR_RADAR_MODE_TX = 1 << 1 # bit 1: enable transmitter
-#bmFR_RADAR_MODE_RX = 1 << 2 # bit 2: enable receiver
-#bmFR_RADAR_MODE_LP = 1 << 3 # bit 3: enable digital loopback
-#bmFR_RADAR_MODE_DR = 1 << 4 # bit 4: enable on-board deramping
-#bmFR_RADAR_MODE_MD = 1 << 5 # bit 5: enable echo metadata
-#bmFR_RADAR_MODE_CHIRPS = 3 << 6 # bit 6,7: number of chirp center frequencies
-
-#FR_RADAR_TON = usrp.FR_USER_1 # 16-bit transmitter on time in clocks
-#FR_RADAR_TSW = usrp.FR_USER_2 # 16-bit transmitter switch time in clocks
-#FR_RADAR_TLOOK = usrp.FR_USER_3 # 16-bit receiver look time in clocks
-#FR_RADAR_TIDLE = usrp.FR_USER_4 # 32-bit inter-pulse idle time
+bmFR_RADAR_TXSIDE = 1 << 1 # bit 1: use TX side A or B
+#bmFR_RADAR_MODE_LP = 1 << 2 # bit 2: enable digital loopback
+#bmFR_RADAR_MODE_DR = 1 << 3 # bit 3: enable on-board deramping
+#bmFR_RADAR_MODE_MD = 1 << 4 # bit 4: enable echo metadata
+#bmFR_RADAR_MODE_CHIRPS = 3 << 5 # bit 5,6: number of chirp center frequencies
+bmFR_RADAR_DEBUG = 1 << 7 # bit 7: enable debugging mode
+
+FR_RADAR_TON = usrp.FR_USER_1 # 16-bit transmitter on time in clocks
+FR_RADAR_TSW = usrp.FR_USER_2 # 16-bit transmitter switch time in clocks
+FR_RADAR_TLOOK = usrp.FR_USER_3 # 16-bit receiver look time in clocks
+FR_RADAR_TIDLE = usrp.FR_USER_4 # 32-bit inter-pulse idle time
FR_RADAR_AMPL = usrp.FR_USER_5 # 16-bit pulse amplitude (2s complement) into CORDIC
-#FR_RADAR_FSTART = usrp.FR_USER_6 # 32-bit FTW for chirp start frequency
-#FR_RADAR_FINCR = usrp.FR_USER_7 # 32-bit FTW increment per transmit clock
-
-# These are for phase II development
-
-# Temporarily use this for transmitter frequency calibration
-FR_RADAR_FREQ1N = usrp.FR_USER_8 # 24-bit N register for chirp #1
-
-FR_RADAR_FREQ1R = usrp.FR_USER_9 # 24-bit R register for chirp #1
-FR_RADAR_FREQ1C = usrp.FR_USER_10 # 24-bit control register for chirp #1
-FR_RADAR_FREQ2N = usrp.FR_USER_11 # 24-bit N register for chirp #2
-FR_RADAR_FREQ2R = usrp.FR_USER_12 # 24-bit R register for chirp #2
-FR_RADAR_FREQ2C = usrp.FR_USER_13 # 24-bit control register for chirp #2
-FR_RADAR_FREQ3N = usrp.FR_USER_14 # 24-bit N register for chirp #3
-FR_RADAR_FREQ3R = usrp.FR_USER_15 # 24-bit R register for chirp #3
-FR_RADAR_FREQ3C = usrp.FR_USER_16 # 24-bit control register for chirp #3
-FR_RADAR_FREQ4N = usrp.FR_USER_17 # 24-bit N register for chirp #4
-FR_RADAR_FREQ4R = usrp.FR_USER_18 # 24-bit R register for chirp #4
-FR_RADAR_FREQ4C = usrp.FR_USER_19 # 24-bit control register for chirp #4
+FR_RADAR_FSTART = usrp.FR_USER_6 # 32-bit FTW for chirp start frequency
+FR_RADAR_FINCR = usrp.FR_USER_7 # 32-bit FTW increment per transmit clock
+FR_RADAR_ATRDEL = usrp.FR_USER_8 # 16-bit TX delay in clocks, 16-bit RX delay in clocks
+
+# These are for phase II development (need to renumber)
+#FR_RADAR_FREQ1N = usrp.FR_USER_8 # 24-bit N register for chirp #1
+#FR_RADAR_FREQ1R = usrp.FR_USER_9 # 24-bit R register for chirp #1
+#FR_RADAR_FREQ1C = usrp.FR_USER_10 # 24-bit C register for chirp #1
+#FR_RADAR_FREQ2N = usrp.FR_USER_11 # 24-bit N register for chirp #2
+#FR_RADAR_FREQ2R = usrp.FR_USER_12 # 24-bit R register for chirp #2
+#FR_RADAR_FREQ2C = usrp.FR_USER_13 # 24-bit C register for chirp #2
+#FR_RADAR_FREQ3N = usrp.FR_USER_14 # 24-bit N register for chirp #3
+#FR_RADAR_FREQ3R = usrp.FR_USER_15 # 24-bit R register for chirp #3
+#FR_RADAR_FREQ3C = usrp.FR_USER_16 # 24-bit C register for chirp #3
+#FR_RADAR_FREQ4N = usrp.FR_USER_17 # 24-bit N register for chirp #4
+#FR_RADAR_FREQ4R = usrp.FR_USER_18 # 24-bit R register for chirp #4
+#FR_RADAR_FREQ4C = usrp.FR_USER_19 # 24-bit C register for chirp #4
#-----------------------------------------------------------------------
# Transmitter object. Uses usrp_sink, but only for a handle to the
# FPGA registers.
#-----------------------------------------------------------------------
-class radar_tx:
- def __init__(self, verbose=False, debug=False):
- self._verbose = verbose
- self._debug = debug
-
+class radar_tx(object):
+ def __init__(self, options):
+ self._subdev_spec = options.tx_subdev_spec
+ self._verbose = options.verbose
+ self._debug = options.debug
self._u = usrp.sink_s(fpga_filename='usrp_radar_mono.rbf')
- self._subdev_spec = (0,0); # FPGA code only implements side A
+
+ if self._subdev_spec == None:
+ self._subdev_spec = usrp.pick_tx_subdevice(self._u)
+
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
+ self._subdev.set_lo_offset(0.0)
+ self._ton_ticks = 0
+ self._tsw_ticks = 0
+ self._tlook_ticks = 0
+ self._tidle_ticks = 0
+
if self._verbose:
print "Using", self._subdev.name(), "for radar transmitter."
+
+ def set_ton(self, ton):
+ self._ton_ticks = 2*(int(ton*64e6)/2)-1 # Even number, then subtract 1
+ if self._verbose:
+ print "Setting pulse on time to", ton, " sec ("+`self._ton_ticks+1`+" ticks)"
+ self._u._write_fpga_reg(FR_RADAR_TON, self._ton_ticks)
+
+ def set_tsw(self, tsw):
+ self._tsw_ticks = 2*(int(tsw*64e6)/2)-1 # Even number, then subtract 1
+ if self._verbose:
+ print "Setting pulse switching time to", tsw, " sec ("+`self._tsw_ticks+1`+" ticks)"
+ self._u._write_fpga_reg(FR_RADAR_TSW, self._tsw_ticks)
+
+ def set_tlook(self, tlook):
+ self._tlook_ticks = 2*(int(tlook*64e6)/2)-1 # Even number, then subtract 1
+ if self._verbose:
+ print "Setting receiver look time to", tlook, " sec ("+`self._tlook_ticks+1`+" ticks)"
+ self._u._write_fpga_reg(FR_RADAR_TLOOK, self._tlook_ticks)
+
+ def set_prf(self, prf):
+ period = 2*int(32e6/prf)
+ self._tidle_ticks = period-(self._ton_ticks+self._tsw_ticks+self._tlook_ticks+3)-1
+ if self._verbose:
+ print "Setting PRF to", prf, "Hz ("+`self._tidle_ticks+1`+" ticks idle time)"
+ self._u._write_fpga_reg(FR_RADAR_TIDLE, self._tidle_ticks)
+
+ def set_amplitude(self, ampl):
+ self._amplitude = int(ampl*9946/100.0) # CORDIC gain correction
+ self._u._write_fpga_reg(FR_RADAR_AMPL, self._amplitude)
- def tune(self, center_freq, waveform_freq):
+ def set_freq(self, center_freq, chirp_width):
self._center_freq = center_freq
- self._waveform_freq = waveform_freq
- self._ftw = int(waveform_freq*(2**32)/32e6)
+ self._chirp_width = chirp_width
+ self._fstart = -int((chirp_width/2)*(2**32)/32e6)
+ self._fincr = int((chirp_width/16e6)*(2**32)/(self._ton_ticks+1))
+
if self._verbose:
print "Setting transmitter center frequency to", n2s(center_freq)
- print "Setting waveform frequency offset to", n2s(waveform_freq), "with ftw of", self._ftw
+ print "Setting chirp width to", n2s(chirp_width), "Hz "+"("+hex(self._fstart)+", "+hex(self._fincr)+")"
+
result = self._u.tune(0, self._subdev, center_freq)
if result == False:
raise RuntimeError("Failed to set transmitter frequency.")
- self._u._write_fpga_reg(FR_RADAR_FREQ1N, self._ftw)
-
- def set_amplitude(self, ampl):
- self._amplitude = int(ampl*9946/100.0) # CORDIC gain correction
- if self._debug:
- print "Writing amplitude register with:", hex(self._amplitude)
- self._u._write_fpga_reg(FR_RADAR_AMPL, self._amplitude)
+ self._u._write_fpga_reg(FR_RADAR_FSTART, self._fstart)
+ self._u._write_fpga_reg(FR_RADAR_FINCR, self._fincr)
def start(self):
self._u.start()
-
+ self._subdev.set_enable(True)
+
def stop(self):
+ self._subdev.set_enable(False)
self._u.stop()
+
+ def subdev_spec(self):
+ return self._subdev_spec
+
+ def echo_length(self):
+ return self._tlook_ticks+1
+
+ def __del__(self):
+ del self._subdev # Avoid weak reference error
#-----------------------------------------------------------------------
# Receiver object. Uses usrp_source_c to receive echo records.
-# NOT IMPLEMENTED YET
#-----------------------------------------------------------------------
-"""
-class radar_rx:
- def __init__(self,gain=None,msgq=None,loopback=False,verbose=False,debug=False):
- self._gain = gain
- self._msgq = msgq
- self._loopback = loopback
- self._verbose = verbose
- self._debug = debug
-
- self._fg = gr.flow_graph()
- self._u = usrp.source_c(fpga_filename='usrp_radar.rbf')
- if not self._loopback:
- self._subdev_spec = (0,0) # FPGA only implements side A
- self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
- self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
- if self._verbose:
- print "Using", self._subdev.name(), "for radar receiver."
+class radar_rx(gr.top_block):
+ def __init__(self, options, callback):
+ gr.top_block.__init__(self, "radar_rx")
- self.set_gain(self._gain)
+ self._u = None
+ self._subdev_spec = options.rx_subdev_spec
+ self._gain = options.gain
+ self._verbose = options.verbose
+ self._debug = options.debug
+ self._callback = callback
+ self._length_set = False
+ self._connected = False
+ self._frequency = 0.0
+ self._msgq = gr.msg_queue()
+ self._watcher = _queue_watcher_thread(self._msgq, self._callback)
+
+ def set_echo_length(self, length):
+ # Only call once
+ if self._length_set is True:
+ raise RuntimeError("Can only set echo length once.")
+ self._length = length
+ self._length_set = True
- # need to compute length here
-
- self._vblen = gr.sizeof_gr_complex*self._length
- if self._debug:
- print "Generating echo vectors of length", self._length, "byte length", self._vblen
-
- self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
- self._sink = gr.message_sink(self._vblen, self._msgq, True)
- self._fg.connect(self._u, self._s2v, self._sink)
-
def tune(self, frequency):
if self._verbose:
print "Setting receiver frequency to", n2s(frequency)
- result = self._u.tune(0, self._subdev, frequency)
- if result == False:
- raise RuntimeError("Failed to set receiver frequency.")
+ self._frequency = frequency
+ if (self._u):
+ result = self._u.tune(0, self._subdev, frequency)
+ if result == False:
+ raise RuntimeError("Failed to set receiver frequency.")
def set_gain(self, gain):
self._gain = gain
- if self._loopback:
- return
-
- if self._gain is None:
+ if self._gain == None:
# if no gain was specified, use the mid-point in dB
g = self._subdev.gain_range()
self._gain = float(g[0]+g[1])/2
- if self._verbose:
- print "Setting receiver gain to", gain
self._subdev.set_gain(self._gain)
- def start(self):
- if self._debug:
- print "Starting receiver flow graph."
- self._fg.start()
+ def begin(self):
+ if not self._connected:
+ self._setup_connections()
+
+ if self._verbose:
+ print "Starting receiver..."
+ self.start()
- def wait(self):
- if self._debug:
- print "Waiting for threads..."
- self._fg.wait()
+ def end(self):
+ if self._verbose:
+ print "Stopping receiver..."
+ self.stop()
+ self.wait()
+ if self._verbose:
+ print "Receiver stopped."
- def stop(self):
- if self._debug:
- print "Stopping receiver flow graph."
- self._fg.stop()
- self.wait()
- if self._debug:
- print "Receiver flow graph stopped."
-"""
-
-class radar:
- def __init__(self,msgq=None,verbose=False,debug=False):
- self._msgq = msgq
- self._verbose = verbose
- self._debug = debug
+ def _setup_usrp(self):
+ self._u = usrp.source_c(fpga_filename='usrp_radar_mono.rbf')
+ if self._subdev_spec == None:
+ self._subdev_spec = usrp.pick_rx_subdevice(self._u)
+ self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
+ self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
- self._mode = 0
- self._transmitting = False
- self._trans = radar_tx(verbose=self._verbose, debug=self._debug)
- self.set_reset(True)
-
- def set_amplitude(self, ampl):
- self._trans.set_amplitude(ampl)
+ if self._verbose:
+ print "Using", self._subdev.side_and_name(), "for radar receiver."
+ print "Setting receiver gain to", self._gain
+ self.set_gain(self._gain)
+ self.tune(self._frequency)
+
+ def _setup_connections(self):
+ if not self._length_set:
+ raise RuntimeError("Echo length not set.")
+ self._setup_usrp()
+ self._vblen = gr.sizeof_gr_complex*self._length
+ self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
+ self._sink = gr.message_sink(self._vblen, self._msgq, False)
+ self.connect(self._u, self._s2v, self._sink)
- def tune(self, center_freq, waveform_freq):
- self._trans.tune(center_freq, waveform_freq)
+ if self._verbose:
+ print "Generating echo vectors of length", self._length, \
+ "(samples)", self._vblen, "(bytes)"
+
+ self._connected = True
+
+class radar(object):
+ def __init__(self, options, callback):
+
+ self._verbose = options.verbose
+ self._debug = options.debug
+ self._mode = 0
+ self._trans = radar_tx(options)
+ self._rcvr = radar_rx(options, callback)
+ self.set_reset(True)
+ self.set_tx_board(self._trans.subdev_spec())
+ self.set_debug(self._debug)
+
def _write_mode(self):
- if self._debug:
- print "Writing mode register with:", hex(self._mode)
self._trans._u._write_fpga_reg(FR_RADAR_MODE, self._mode)
- def enable_tx(self, value):
+ def set_reset(self, value):
if value:
- if self._verbose:
- print "Enabling transmitter."
- self._mode |= bmFR_RADAR_MODE_TX
- self._transmitting = True
+ self._mode |= bmFR_RADAR_MODE_RESET
else:
- if self._verbose:
- print "Disabling transmitter."
- self._mode &= ~bmFR_RADAR_MODE_TX
- self._transmitting = False
+ self._mode &= ~bmFR_RADAR_MODE_RESET
self._write_mode()
-
- """
- def enable_rx(self, value):
- if value:
- self._mode |= bmFR_RADAR_MODE_RX
- self._write_mode()
- self._rcvr.start()
- self._receiving = True
- else:
- self._rcvr.stop()
- self._mode &= ~bmFR_RADAR_MODE_RX
- self._write_mode()
- self._receiving = False
- """
- """
- def set_loopback(self, value):
- if value:
- if self._verbose:
- print "Enabling digital loopback."
- self._mode |= bmFR_RADAR_MODE_LP
+
+ def set_tx_board(self, tx_subdev_spec):
+ if tx_subdev_spec[0] == 1:
+ self._mode |= bmFR_RADAR_TXSIDE
else:
- if self._verbose:
- print "Disabling digital loopback."
- self._mode &= ~bmFR_RADAR_MODE_LP
+ self._mode &= ~bmFR_RADAR_TXSIDE
self._write_mode()
- """
-
- def set_reset(self, value):
+
+ def set_debug(self, value):
if value:
- if self._debug:
- print "Asserting reset."
- self._mode |= bmFR_RADAR_MODE_RESET
+ self._mode |= bmFR_RADAR_DEBUG
else:
- if self._debug:
- print "De-asserting reset."
- self._mode &= ~bmFR_RADAR_MODE_RESET
+ self._mode &= ~bmFR_RADAR_DEBUG
self._write_mode()
+
+ def set_ton(self, ton):
+ self._trans.set_ton(ton)
+
+ def set_tsw(self, tsw):
+ self._trans.set_tsw(tsw)
+
+ def set_tlook(self, tlook):
+ self._trans.set_tlook(tlook)
+ self._rcvr.set_echo_length(self._trans.echo_length())
+
+ def set_prf(self, prf):
+ self._trans.set_prf(prf)
+
+ def set_amplitude(self, ampl):
+ self._trans.set_amplitude(ampl)
+
+ def set_freq(self, center_freq, chirp_width):
+ self._trans.set_freq(center_freq, chirp_width)
+ self._rcvr.tune(center_freq)
+
+ def set_atrdel(self, tx_delay, rx_delay):
+ if self._verbose:
+ print "Setting TX delay of", tx_delay, "clocks, RX delay of", rx_delay
+ self._trans._u._write_fpga_reg(FR_RADAR_ATRDEL, tx_delay << 16 | rx_delay)
def start(self):
- self._trans.start()
- self.enable_tx(True)
self.set_reset(False)
+ self._trans.start()
+ self._rcvr.begin()
def stop(self):
- self.set_reset(True)
+ self._rcvr.end()
self._trans.stop()
- if self._transmitting:
- self.enable_tx(False)
+ self.set_reset(True)
+
+#-----------------------------------------------------------------------
+# Queue watcher. Dispatches received echos to callback.
+#-----------------------------------------------------------------------
+class _queue_watcher_thread(_threading.Thread):
+ def __init__(self, msgq, callback):
+ _threading.Thread.__init__(self)
+ self.setDaemon(1)
+ self._msgq = msgq
+ self._callback = callback
+ self._keep_running = True
+ self.start()
+
+ def run(self):
+ while self._keep_running == True:
+ msg = self._msgq.delete_head()
+ if self._callback:
+ self._callback(msg.to_string())
- def __del__(self):
- self.stop()
projects / debian / gnuradio / blobdiff