def set_freq(self, freq, skip_sync=False):
"""
Safely tune all channels to freq.
"""
self.vprint("Tuning all channels to {freq} MHz.".format(freq=freq/1e6))
# Set frequency (tune request takes lo_offset):
if hasattr(self.args, 'lo_offset') and self.args.lo_offset is not None:
treq = uhd.tune_request(freq, self.args.lo_offset)
else:
treq = uhd.tune_request(freq)
# Make sure tuning is synched:
if len(self.channels) > 1 and not skip_sync:
cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY)
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.set_command_time(cmd_time, mb_idx)
for chan in self.channels:
self.tr = self.usrp.set_center_freq(treq, chan)
if self.tr == None:
sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format(
prefix=self.prefix, chan=chan
))
exit(1)
if len(self.channels) > 1 and not skip_sync:
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.clear_command_time(mb_idx)
self.vprint("Syncing channels...".format(prefix=self.prefix))
time.sleep(COMMAND_DELAY)
self.freq = self.usrp.get_center_freq(self.channels[1])
self.vprint("First channel has freq: {freq} MHz.".format(freq=self.freq/1e6))
def retune(self): up_freq = self._dssdr_channels[self._ccsds_channel][0] down_freq = self._dssdr_channels[self._ccsds_channel][1] if self.options.test == False and self.options.fromfile == False and self.options.frombitlog == False: self._tune_request = uhd.tune_request(down_freq-self._dssdr_mixer_freq+self._if_freq, self._uhd_carrier_offset) self.u.set_center_freq(self._tune_request) if self.options.test == False and self.options.tofile == False and self.options.tonull == False: self._tune_request = uhd.tune_request(self._dssdr_mixer_freq-up_freq+self._if_freq, self._uhd_carrier_offset) self.u_tx.set_center_freq(self._tune_request)
def set_freq(self, freq):
self.freq = freq
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq - self.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq - self.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1)
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.set_resamp_rate(float(self.interp / self.decim * self.samp_rate))
self.fosphor_qt_sink_c_0.set_frequency_range(0, self.samp_rate)
self.fosphor_qt_sink_c_0_0.set_frequency_range(0, self.samp_rate)
self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.rx_freq, self.samp_rate / 2), 1)
def set_system_center_freq(self, system_center_freq):
self.system_center_freq = system_center_freq
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.com_freq_entry_1,
rf_freq=self.system_center_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.vor_freq_entry_1,
rf_freq=self.system_center_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1)
def set_rx_freq(self, rx_freq):
self.rx_freq = rx_freq
Qt.QMetaObject.invokeMethod(self._rx_freq_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.rx_freq)))
self.fosphor_qt_sink_c_0.set_frequency_range(self.rx_freq, self.samp_rate)
self.fosphor_qt_sink_c_0_0.set_frequency_range(self.rx_freq, self.samp_rate)
self.qtgui_freq_sink_x_0.set_frequency_range(self.rx_freq, self.samp_rate)
self.qtgui_waterfall_sink_x_0.set_frequency_range(self.rx_freq, self.samp_rate)
self.qtgui_waterfall_sink_x_0_0.set_frequency_range(self.rx_freq, self.samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2), 0)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2), 1)
def set_tuning_lo_offset(self, tuning_lo_offset):
self.tuning_lo_offset = tuning_lo_offset
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq, self.tuning_lo_offset), 0)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq, self.tuning_lo_offset), 1)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(self.freq, self.tuning_lo_offset), 0)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(self.freq, self.tuning_lo_offset), 1)
def retune(self, freq, lo_offset, gain, bw):
# synchronize LOs
time_retune_2 = self.usrp_source.get_time_now().get_real_secs()
print "Time retune 2:", time_retune_2
self.usrp_source.set_center_freq(uhd.tune_request(freq, lo_offset), 0)
self.tx_bpsk_0.set_center_freq(uhd.tune_request(freq, lo_offset))
self.usrp_source.set_gain(gain,0)
self.tx_bpsk_0.set_gain(gain)
self.usrp_source.set_bandwidth(bw,0)
self.tx_bpsk_0.set_bandwidth(bw)
def set_lo_offset(self, lo_offset):
self.lo_offset = lo_offset
self.uhd_usrp_sink_0_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq - self.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq - self.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_freq(self, freq, skip_sync=False):
"""
Safely tune all channels to freq.
"""
self.vprint("Tuning all channels to {freq} MHz.".format(freq=freq / 1e6))
# Set frequency (tune request takes lo_offset):
if hasattr(self.args, 'lo_offset') and self.args.lo_offset is not None:
treq = uhd.tune_request(freq, self.args.lo_offset)
else:
treq = uhd.tune_request(freq)
# Special TwinRX tuning due to LO sharing
if getattr(self, 'lo_source_channel', None) is not None:
tune_resp = self.usrp.set_center_freq(treq, self.lo_source_channel)
if getattr(self.args, 'lo_offset', None) is not None:
treq = uhd.tune_request(
target_freq=freq,
rf_freq=freq+self.args.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
else:
treq = uhd.tune_request(
target_freq=freq,
rf_freq=freq,
rf_freq_policy=uhd.tune_reqest.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
for chan in self.channels:
if chan == self.lo_source_channel:
continue
self.usrp.set_center_freq(treq, chan)
# Make sure tuning is synched:
command_time_set = False
if len(self.channels) > 1 and not skip_sync:
cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY)
try:
for mb_idx in range(self.usrp.get_num_mboards()):
self.usrp.set_command_time(cmd_time, mb_idx)
command_time_set = True
except RuntimeError:
sys.stderr.write('[{prefix}] [WARNING] Failed to set command times.\n'.format(prefix=self.prefix))
for i, chan in enumerate(self.channels):
self.tr = self.usrp.set_center_freq(treq, i)
if self.tr is None:
sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format(
prefix=self.prefix, chan=chan
))
sys.exit(1)
if command_time_set:
for mb_idx in range(self.usrp.get_num_mboards()):
self.usrp.clear_command_time(mb_idx)
self.vprint("Syncing channels...".format(prefix=self.prefix))
time.sleep(COMMAND_DELAY)
self.freq = self.usrp.get_center_freq(0)
self.vprint("First channel has freq: {freq} MHz.".format(freq=self.freq / 1e6))
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
Qt.QMetaObject.invokeMethod(self._samp_rate_line_edit, "setText", Qt.Q_ARG("QString", eng_notation.num_to_str(self.samp_rate)))
self.uhd_usrp_source_1.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_1.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2.0), 0)
self.uhd_usrp_source_1.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2.0), 1)
self.set_samps_per_symb(self.samp_rate/10/self.decim*self.interp/self.baud)
self.qtgui_waterfall_sink_x_0_0.set_frequency_range(0, self.samp_rate)
self.qtgui_waterfall_sink_x_0.set_frequency_range(0, self.samp_rate)
self.qtgui_freq_sink_x_0_0.set_frequency_range(0, self.samp_rate)
self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate)
def set_freq(self, freq):
self.freq = freq
self._freq_callback(self.freq)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_freq(self, freq):
self.freq = freq
r = self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=(self.freq + self.lo_offset),
rf_freq_policy=uhd.tune_request.POLICY_MANUAL))
g = self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=(self.freq + self.lo_offset),
rf_freq_policy=uhd.tune_request.POLICY_MANUAL))
print "USRP Sink ", r
print "USRP Source ", g
def set_freq(self, freq, skip_sync=False):
"""
Safely tune all channels to freq.
"""
self.vprint("Tuning all channels to {freq} MHz.".format(freq=freq/1e6))
# Set frequency (tune request takes lo_offset):
if hasattr(self.args, 'lo_offset') and self.args.lo_offset is not None:
treq = uhd.tune_request(freq, self.args.lo_offset)
else:
treq = uhd.tune_request(freq)
# Special TwinRX tuning due to LO sharing
if getattr(self, 'lo_source_channel', None) is not None:
tune_resp = self.usrp.set_center_freq(treq, self.lo_source_channel)
if getattr(self.args, 'lo_offset', None) is not None:
treq = uhd.tune_request(target_freq=freq, rf_freq=freq+self.args.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
else:
treq = uhd.tune_request(target_freq=freq, rf_freq=freq, rf_freq_policy=uhd.tune_reqest.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
for chan in self.channels:
if chan == self.lo_source_channel:
continue
self.usrp.set_center_freq(treq,chan)
# Make sure tuning is synched:
command_time_set = False
if len(self.channels) > 1 and not skip_sync:
cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY)
try:
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.set_command_time(cmd_time, mb_idx)
command_time_set = True
except RuntimeError:
sys.stderr.write('[{prefix}] [WARNING] Failed to set command times.\n'.format(prefix=self.prefix))
for i, chan in enumerate(self.channels ):
self.tr = self.usrp.set_center_freq(treq, i)
if self.tr == None:
sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format(
prefix=self.prefix, chan=chan
))
exit(1)
if command_time_set:
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.clear_command_time(mb_idx)
self.vprint("Syncing channels...".format(prefix=self.prefix))
time.sleep(COMMAND_DELAY)
self.freq = self.usrp.get_center_freq(0)
self.vprint("First channel has freq: {freq} MHz.".format(freq=self.freq/1e6))
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
Qt.QMetaObject.invokeMethod(
self._samp_rate_line_edit, "setText",
Qt.Q_ARG("QString", eng_notation.num_to_str(self.samp_rate)))
self.uhd_usrp_source_0_0.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_0_0.set_center_freq(
uhd.tune_request(self.fc_modes, self.samp_rate / 2), 0)
self.uhd_usrp_source_0.set_samp_rate(self.samp_rate * 2)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.fc_tcas, self.samp_rate / 2), 0)
self.qtgui_freq_sink_x_0_0.set_frequency_range(0, self.samp_rate)
self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate)
self.fosphor_qt_sink_c_0_0.set_frequency_range(0, self.samp_rate)
self.fosphor_qt_sink_c_0.set_frequency_range(0, self.samp_rate * 2)
def set_freq(self, freq=None, lo_offset=None):
if(freq is None):
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
sys.exit(1)
r = self.u.set_center_freq(uhd.tune_request(freq, lo_offset),0)
if(self._ismimo):
s = self.u.set_center_freq(uhd.tune_request(freq, lo_offset),1)
if r:
return "FREQ", freq
else:
frange = self.u.get_freq_range()
sys.stderr.write(("\nRequested frequency (%f) out or range [%f, %f]\n") % \
(freq, frange.start(), frange.stop()))
sys.exit(1)
def set_freq(self, freq=None, lo_offset=None):
if (freq is None):
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
sys.exit(1)
r = self.u.set_center_freq(uhd.tune_request(freq, lo_offset), 0)
if (self._ismimo):
s = self.u.set_center_freq(uhd.tune_request(freq, lo_offset), 1)
if r:
return "FREQ", freq
else:
frange = self.u.get_freq_range()
sys.stderr.write(("\nRequested frequency (%f) out or range [%f, %f]\n") % \
(freq, frange.start(), frange.stop()))
sys.exit(1)
def __init__(self):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 25e6
self.lo_off = lo_off = 0
self.gain = gain = 28
self.freq_l2 = freq_l2 = 1.22760e9
self.freq_l1 = freq_l1 = 1.57542e9
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="addr0=192.168.10.3,addr1=192.168.10.2",
stream_args=uhd.stream_args(
cpu_format="sc16",
otw_format="sc8",
channels=range(2),
),
)
self.uhd_usrp_source_0.set_clock_source("gpsdo", 0)
self.uhd_usrp_source_0.set_time_source("gpsdo", 0)
self.uhd_usrp_source_0.set_clock_source("mimo", 1)
self.uhd_usrp_source_0.set_time_source("mimo", 1)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(freq_l1, lo_off), 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.uhd_usrp_source_0.set_antenna("RX2", 0)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(freq_l2, lo_off), 1)
self.uhd_usrp_source_0.set_gain(gain, 1)
self.uhd_usrp_source_0.set_antenna("RX2", 1)
self.blocks_file_sink_1 = blocks.file_sink(
gr.sizeof_int * 1, "/media/is4s/512GB_SSD/usrp_l2.dat", False)
self.blocks_file_sink_1.set_unbuffered(False)
self.blocks_file_sink_0 = blocks.file_sink(
gr.sizeof_int * 1, "/media/is4s/512GB_SSD/usrp_l1.dat", False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.uhd_usrp_source_0, 1), (self.blocks_file_sink_1, 0))
def set_freq(self, freq):
self.freq = freq
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq - self.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
self.ieee802_11_frame_equalizer_0.set_frequency(self.freq)
def setup_usrp_sources(self):
print 'setup_usrp_sources'
self.rcvs = []
for i in range(self.n_devices):
self.rcvs.append(
uhd.usrp_source(
self.addrs[i],
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
))
if (self._node_type == CLUSTER_NODE):
self.rcvs[i].set_start_on_demand(
) # the sensor will start sensing onmand
if self.rcvs[i].get_time_source(0) == "none":
self.rcvs[i].set_time_source(
"mimo", 0) # Set the time source without GPS to MIMO cable
self.rcvs[i].set_clock_source("mimo", 0)
else:
self.rcvs[i].set_clock_source("external", 0)
self.rcvs[i].set_samp_rate(self.sample_rate)
#self.rcvs[i].set_center_freq(self.center_freq, 0)
self.rcvs[i].set_center_freq(
uhd.tune_request(self.center_freq, self.sample_rate * 12), 0)
if (self.rx_gain):
self.rcvs[i].set_gain(self.rx_gain, 0)
self.rcvs[i].set_antenna("RX2", 0)
def _init_rx_connection(self, ettus_id, samp_rate, freq_0, freq_offset, gain):
"""
Establish a recieving connection to an Ettus device uing the UHD protocol.
Parameters
----------
ettus_id : str
The serial number of the ettus device
samp_rate : int
The sample rate desired from the reciever.
freq_0 : float
The desired centre frequency of the passband
freq_offset : float
The local oscillator offset, used to remove the peak produced by the LO.
gain : float
The desired gain from the receiver.
"""
#
# We need to set up a connection to the Ettus receiver
#
self.rx_con = uhd.usrp_source( ",".join(("serial="+ettus_id, "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
)
)
self.rx_con.set_samp_rate(samp_rate)
self.rx_con.set_center_freq(uhd.tune_request(freq_0 , -freq_offset), 0)
self.rx_con.set_gain(gain, 0)
def set_center_freq(self, center_freq, sources):
# Tune all channels to the desired frequency
tune_resp = self.uhd_usrp_source_0.set_center_freq(center_freq, 0)
tune_req = uhd.tune_request(
rf_freq=center_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
self.uhd_usrp_source_0.set_center_freq(tune_req, 1)
if sources == 4:
self.uhd_usrp_source_0.set_center_freq(tune_req, 2)
self.uhd_usrp_source_0.set_center_freq(tune_req, 3)
# Synchronize the tuned channels
now = self.uhd_usrp_source_0.get_time_now()
self.uhd_usrp_source_0.set_command_time(now + uhd.time_spec(0.01))
self.uhd_usrp_source_0.set_center_freq(tune_req, 0)
self.uhd_usrp_source_0.set_center_freq(tune_req, 1)
if sources == 4:
self.uhd_usrp_source_0.set_center_freq(tune_req, 2)
self.uhd_usrp_source_0.set_center_freq(tune_req, 3)
self.uhd_usrp_source_0.clear_command_time()
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.set_samp_per_sym(
(self.samp_rate / self.decim / 50 * 48) / self.baud)
self.uhd_usrp_source_1.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_1.set_center_freq(
uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0)
self.qtgui_waterfall_sink_x_0_1.set_frequency_range(
self.rx_freq, self.samp_rate / 2)
self.qtgui_freq_sink_x_0.set_frequency_range(self.rx_freq,
self.samp_rate / 2)
self.low_pass_filter_0_0.set_taps(
firdes.low_pass(1, self.samp_rate, 7e3, 1e3, firdes.WIN_HAMMING,
6.76))
self.low_pass_filter_0.set_taps(
firdes.low_pass(1, self.samp_rate, 7e3, 1e3, firdes.WIN_HAMMING,
6.76))
self.analog_sig_source_x_1.set_sampling_freq(self.samp_rate)
self.analog_sig_source_x_0_0.set_sampling_freq(self.samp_rate)
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)
self.analog_quadrature_demod_cf_0_0.set_gain(
(self.samp_rate / self.decim) /
(2 * math.pi * self.fsk_deviation / 8.0))
self.analog_quadrature_demod_cf_0.set_gain(
(self.samp_rate / self.decim) /
(2 * math.pi * self.fsk_deviation / 8.0))
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.rx_freq, self.samp_rate/2), 0)
self.qtgui_waterfall_sink_x_0.set_frequency_range(0, self.samp_rate)
self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate)
self.set_fn("ORBCOMM_{:s}_{:s}_{:s}_{:s}k.fc32".format(self.sat_name, self.radio_id, self.ts_str, str(int(self.samp_rate/self.decim)/1000)))
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.freq, self.samp_rate/2), 0)
self.qtgui_waterfall_sink_x_0.set_frequency_range(0, self.samp_rate)
self.qtgui_time_sink_x_0.set_samp_rate(self.samp_rate)
self.qtgui_freq_sink_x_0.set_frequency_range(0, self.samp_rate)
def set_fine(self, fine):
self.fine = fine
Qt.QMetaObject.invokeMethod(
self._fine_line_edit, "setText",
Qt.Q_ARG("QString", eng_notation.num_to_str(self.fine)))
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.rx_freq + self.fine, self.samp_rate / 2), 0)
def __init__(self, options, filename):
gr.top_block.__init__(self)
inf_str = None
symbol_rate = 152.34e3
sample_rate = 1e6
#if len(options) != 0:
# inf_str = args[0]
squelch = analog.pwr_squelch_cc(float(options.squelch), 0.1, 0, True)
demod = analog.quadrature_demod_cf(1.0)
cr = digital.clock_recovery_mm_ff(sample_rate/symbol_rate, 0.00765625, 0, 0.175, 0.005)
slicer = digital.binary_slicer_fb()
corr = digital.correlate_access_code_bb(AC, 3)
sink = sniffer()
if False:
print "Reading from: " + inf_str
src = blocks.file_source(gr.sizeof_gr_complex, inf_str, False)
else:
freqs = {
'AA':917.0e6, 'AB':913.0e6, 'AC':914.0e6, 'AD':915.0e6,
'BA':916.0e6, 'BB':919.0e6, 'BC':920.0e6, 'BD':921.0e6,
'CA':922.0e6, 'CB':923.0e6, 'CC':907.0e6, 'CD':908.0e6,
'DA':905.5e6, 'DB':909.0e6, 'DC':911.0e6, 'DD':910.0e6}
frequency = freqs[options.channel]
print "Channel: " + options.channel + " (" + str(frequency/1e6) + "MHz)"
# Create a UHD device source
src = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32', "sc16", args=""))
# Set the subdevice spec
if(options.spec):
src.set_subdev_spec(options.spec, 0)
# Set the antenna
if(options.antenna):
src.set_antenna(options.antenna, 0)
# Set receiver sample rate
src.set_samp_rate(options.samp_rate)
# Set receive daughterboard gain
if options.gain is None:
g = src.get_gain_range()
options.gain = float(g.start()+g.stop())/2
print "Using mid-point gain of", options.gain, "(", g.start(), "-", g.stop(), ")"
src.set_gain(options.gain)
# Set frequency (tune request takes lo_offset)
treq = uhd.tune_request(frequency)
tr = src.set_center_freq(treq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
self.connect(src, squelch, demod, cr, slicer, corr, sink)
def set_tx_freq(self, tx_freq):
self.tx_freq = tx_freq
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(self.tx_freq,
dsp_freq=0,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL),
0)
def set_rx_freq(self, rx_freq):
self.rx_freq = rx_freq
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.rx_freq,
dsp_freq=0,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL),
0)
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.set_decim(self.samp_rate / 1e3)
self.uhd_usrp_source_1_0.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_1_0.set_center_freq(
uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0)
self.qtgui_time_sink_x_0_0.set_samp_rate(self.samp_rate / self.decim *
self.interp / 3 / 4)
self.qtgui_time_sink_x_0.set_samp_rate(self.samp_rate / self.decim *
self.interp / 3)
self.qtgui_freq_sink_x_0_0.set_frequency_range(
0, self.samp_rate / self.decim * self.interp / 3)
self.qtgui_freq_sink_x_0.set_frequency_range(
0, self.samp_rate / self.decim * self.interp)
self.low_pass_filter_0_1.set_taps(
firdes.low_pass(1, self.samp_rate / self.decim * self.interp / 3,
1.5e3, 100, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0_0_0.set_taps(
firdes.low_pass(1, self.samp_rate / self.decim * self.interp,
self.lpf_cutoff, 100, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0_0.set_taps(
firdes.low_pass(1, self.samp_rate / self.decim * self.interp,
self.lpf_cutoff, 100, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0.set_taps(
firdes.low_pass(1, self.samp_rate / self.decim * self.interp / 3,
1.5e3, 100, firdes.WIN_HAMMING, 6.76))
self.fosphor_qt_sink_c_0.set_frequency_range(
self.rx_freq, self.samp_rate / int(self.samp_rate / 1e3) * 200)
self.analog_sig_source_x_0_0_0.set_sampling_freq(
self.samp_rate / self.decim * self.interp / 3)
self.analog_sig_source_x_0_0.set_sampling_freq(
self.samp_rate / self.decim * self.interp / 3)
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)
def set_freq(self, freq):
self.freq = freq
self.wifi_phy_hier_0.set_frequency(self.freq)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request(self.freq,
rf_freq=self.freq - self.lo_offset,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0)
def set_RF_tuner(self, RF_tuner):
self.RF_tuner = RF_tuner
self.cwradar_doppler_velocity_single_target_ff_0.set_radar_freq(self.RF_tuner)
self._RF_tuner_slider.set_value(self.RF_tuner)
self._RF_tuner_text_box.set_value(self.RF_tuner)
self.usrp_receiver.set_center_freq(uhd.tune_request(self.RF_tuner, self.lo_offset_freq), 0)
self.usrp_transmitter.set_center_freq(self.RF_tuner, 0)
def set_apt_freq(self, apt_freq):
self.apt_freq = apt_freq
Qt.QMetaObject.invokeMethod(
self._apt_freq_line_edit, "setText",
Qt.Q_ARG("QString", eng_notation.num_to_str(self.apt_freq)))
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.apt_freq, self.samp_rate / 2), 0)
def __init__(self):
gr.top_block.__init__(self)
self.samp_rate = samp_rate = 1000000
self.dump_freq = dump_freq = 2400490000
self._u = uhd.usrp_source(
device_addr="%default",
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
self._u.set_gain(0, 0)
self._u.set_samp_rate(self.samp_rate)
treq = uhd.tune_request(self.dump_freq, 0)
tr = self._u.set_center_freq(treq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
self.filter1 = gr.interp_fir_filter_ccf(1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76))
self.squelch = gr.pwr_squelch_cc(-100, 0.001, 0, True)
self.demod = gr.quadrature_demod_cf(1)
self.sync = digital.clock_recovery_mm_ff(2, 0.0076562, 0.5, 0.175, 0.005)
self.slicer = digital.binary_slicer_fb()
self.detect_seq = digital.correlate_access_code_bb("01010101010101010101010101010101", 1)
self.dump = flysky.dumpsync()
self.connect(self._u,self.filter1,self.squelch,self.demod,self.sync,self.slicer,self.detect_seq, self.dump)
def set_frequency(self, freq):
tune_request = uhd.tune_request(freq, self.profile.usrp_lo_offset)
if self.profile.usrp_use_integerN_tuning:
tune_request.args = uhd.device_addr('mode_n=integer')
tune_result = self.usrp.set_center_freq(tune_request)
print(tune_result.to_pp_string())
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.set_samps_per_symb(self.samp_rate / self.decim / self.baud)
self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.rx_freq, self.samp_rate / 2), 0)
self.qtgui_waterfall_sink_x_0_0.set_frequency_range(
0, self.samp_rate / self.decim)
self.qtgui_waterfall_sink_x_0.set_frequency_range(
0, self.samp_rate / self.decim)
self.qtgui_time_sink_x_0.set_samp_rate(self.samp_rate / self.decim /
50 * 48)
self.qtgui_freq_sink_x_0.set_frequency_range(
0, self.samp_rate / self.decim)
self.low_pass_filter_0_0_0.set_taps(
firdes.low_pass(1, self.samp_rate / self.decim / 50 * 48,
self.audio_lpf_cutoff, 2e3, firdes.WIN_HAMMING,
6.76))
self.low_pass_filter_0_0.set_taps(
firdes.low_pass(1, self.samp_rate / self.decim, self.rf_lpf_cutoff,
2e3, firdes.WIN_HAMMING, 6.76))
self.set_fn("{:s}_{:s}_{:s}_{:s}k.fc32".format(
self.sat_name, self.radio_id, self.ts_str,
str(int(self.samp_rate) / 1000)))
self.blocks_multiply_const_vxx_1.set_k(
(-1 * self.samp_rate / self.decim / (2 * math.pi), ))
self.blocks_keep_one_in_n_0_0.set_n(
int(self.samp_rate * self.meta_rate))
self.blocks_keep_one_in_n_0.set_n(
int(self.samp_rate / 4 * self.meta_rate))
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)
self.analog_sig_source_x_0.set_frequency(self.samp_rate / 2)
self.analog_quadrature_demod_cf_0.set_gain(
self.samp_rate / (2 * math.pi * self.fsk_deviation_hz / 8.0))
def __init__(self):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 25e6
self.lo_off = lo_off = 0
self.freq_l1 = freq_l1 = 1.57542e6
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="sc16",
otw_format="sc16",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_clock_source("gpsdo", 0)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l1, lo_off), 0)
self.uhd_usrp_source_0.set_gain(35, 0)
self.uhd_usrp_source_0.set_antenna("RX2", 0)
#self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
#self.uhd_usrp_source_0.set_bandwidth(20e6, 0)
self.blocks_vector_sink_x_0 = blocks.vector_sink_i(1)
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.blocks_vector_sink_x_0, 0))
def set_vor_freq_entry_1(self, vor_freq_entry_1):
self.vor_freq_entry_1 = vor_freq_entry_1
self.uhd_usrp_source_0.set_center_freq(
uhd.tune_request(self.vor_freq_entry_1,
rf_freq=self.band_center_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1)
self._vor_freq_entry_1_text_box.set_value(self.vor_freq_entry_1)
def set_freq(self, target_freq):
"""
Set the center frequency we're interested in.
@param target_freq: frequency in Hz
@rypte: bool
"""
#r = self.u.set_center_freq(target_freq, 0)
r = self.u.set_center_freq(uhd.tune_request(target_freq, 4e6), 0)
print '%s ' % (r.to_pp_string())
self.u.stop()
print 'In locking '
while (self.u.get_sensor("lo_locked").to_bool() == False):
print '.'
print 'Locked'
print 'actual center freq = %d ' % (self.u.get_center_freq() + 5000000)
self.u.start()
if r:
self.myform['freq'].set_value(self.u.get_center_freq() + 5000000)
self.myform['rffreq'].set_value(r.actual_rf_freq)
self.myform['dspfreq'].set_value(r.actual_dsp_freq)
if not self.options.oscilloscope:
self.scope.set_baseband_freq(target_freq)
return True
return False
def __init__(self, filename, dev_addrs,
onebit, gain, digital_gain, fs, fc, sync_pps):
gr.top_block.__init__(self)
if onebit:
raise NotImplementedError("TODO: 1-bit mode not implemented.")
uhd_srcs = [
uhd.usrp_source(",".join(
[addr, "num_recv_frames=256,recv_frame_size=16384"]),
uhd.stream_args(
cpu_format="fc32",
otwformat="sc16",
channels=[0]))
for addr in dev_addrs]
str2vec = blocks.streams_to_vector(2, len(uhd_srcs))
self.connect(str2vec,
blocks.stream_to_vector(2 * len(uhd_srcs), 16*1024*1024),
blocks.file_sink(2 * len(uhd_srcs) * 16 * 1024 * 1024, filename, False))
for ix, src in enumerate(uhd_srcs):
src.set_clock_rate(fs*2, uhd.ALL_MBOARDS)
src.set_samp_rate(fs)
src.set_center_freq(uhd.tune_request(fc, 3e6))
src.set_gain(gain, 0)
# TODO Use offset tuning?
if sync_pps:
src.set_clock_source("external") # 10 MHz
src.set_time_source("external") # PPS
self.connect(src, # [-1.0, 1.0]
blocks.multiply_const_cc(32767 * digital_gain[ix]), # [-32767.0, 32767.0]
blocks.complex_to_interleaved_short(), #[-32768, 32767]
blocks.short_to_char(), #[-128, 127]
blocks.stream_to_vector(1, 2), # I,Q,I,Q -> IQ, IQ
(str2vec, ix))
print "Setting clocks..."
if sync_pps:
time.sleep(1.1) # Ensure there's been an edge. TODO: necessary?
last_pps_time = uhd_srcs[0].get_time_last_pps()
while last_pps_time == uhd_srcs[0].get_time_last_pps():
time.sleep(0.1)
print "Got edge"
[src.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for src in uhd_srcs]
time.sleep(1.0) # Wait for edge to set the clocks
else:
# No external PPS/10 MHz. Just set each clock and accept some skew.
t = time.time()
[src.set_time_now(uhd.time_spec(time.time())) for src in uhd_srcs]
if len(uhd_srcs) > 1:
print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % (
(time.time()-t) * 1000)
t_start = uhd.time_spec(time.time() + 1.5)
[src.set_start_time(t_start) for src in uhd_srcs]
print "ready"
def __init__(self):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 25e6
self.lo_off = lo_off = 0
self.gain = gain = 28
self.freq_l2 = freq_l2 = 1.22760e9
self.freq_l1 = freq_l1 = 1.57542e9
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="addr0=192.168.10.3,addr1=192.168.10.2",
stream_args=uhd.stream_args(
cpu_format="sc16",
otw_format="sc8",
channels=range(2),
),
)
self.uhd_usrp_source_0.set_clock_source("gpsdo", 0)
self.uhd_usrp_source_0.set_time_source("gpsdo", 0)
self.uhd_usrp_source_0.set_clock_source("mimo", 1)
self.uhd_usrp_source_0.set_time_source("mimo", 1)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l1, lo_off), 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.uhd_usrp_source_0.set_antenna("RX2", 0)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq_l2, lo_off), 1)
self.uhd_usrp_source_0.set_gain(gain, 1)
self.uhd_usrp_source_0.set_antenna("RX2", 1)
self.blocks_file_sink_1 = blocks.file_sink(gr.sizeof_int*1, "/media/is4s/512GB_SSD/usrp_l2.dat", False)
self.blocks_file_sink_1.set_unbuffered(False)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_int*1, "/media/is4s/512GB_SSD/usrp_l1.dat", False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.uhd_usrp_source_0, 1), (self.blocks_file_sink_1, 0))
def set_frequency(self, frequency):
"""
Method to tune the USRP to the desired frequency.
Args:
frequency: Desired center freqeuncy
"""
if self.center_freq != frequency:
print "Tuning to", frequency / 1e9, "GHz"
self.center_freq = frequency
self.uhd.set_center_freq(uhd.tune_request(frequency, self.lo_offset), 0)
def set_freq(self, target_freq):
"""
Set the center frequency we're interested in.
@param target_freq: frequency in Hz
@rypte: bool
"""
r = self.u.set_center_freq(uhd.tune_request(target_freq, rf_freq=(target_freq + self.lo_offset),rf_freq_policy=uhd.tune_request.POLICY_MANUAL))
if r:
return True
return False
def __init__(self, args, sym_rate, sps, freq=None, lo_offset=None, gain=None,
spec=None, antenna=None, clock_source=None, verbose=False):
gr.hier_block2.__init__(self, "uhd_receiver",
gr.io_signature(0,0,0),
gr.io_signature(1,1,gr.sizeof_gr_complex))
# Set up the UHD interface as a receiver
uhd_interface.__init__(self, False, args, sym_rate, sps,
freq, lo_offset, gain, spec, antenna, clock_source)
# Set frequency (tune request takes lo_offset)
if(options.lo_offset is not None):
treq = uhd.tune_request(freq, options.lo_offset)
else:
treq = uhd.tune_request(freq)
tr = self.u.set_center_freq(treq)
if tr == None:
sys.stderr.write('Failed to set center frequency\n')
raise SystemExit, 1
self.connect(self.u, self)
if(verbose):
self._print_verbage()
def setup_usrp_sinks(self):
print 'setup_usrp_sinks'
self.sinks = []
for i in range(self.n_devices):
self.sinks.append(uhd.usrp_sink(self.addrs[i],
stream_args=uhd.stream_args(cpu_format="fc32",
channels=range(1),
),
)
)
self.sinks[i].set_samp_rate(self.sample_rate)
#self.sinks[i].set_center_freq(self.center_freq, 0)
self.sinks[i].set_center_freq(uhd.tune_request(self.center_freq, self.sample_rate*12), 0)
if(self.tx_gain):
self.sinks[i].set_gain(self.tx_gain, 0)
self.sinks[i].set_antenna("TX/RX", 0)
if self.sinks[i].get_time_source(0) == "none":
self.sinks[i].set_time_source("mimo", 0) # Set the time source without GPS to MIMO cable
self.sinks[i].set_clock_source("mimo",0)
else:
self.sinks[i].set_clock_source("external", 0)
#generate the random datafile for the transmitter if read data from file
if self.randbinfile != 0:
txfile_name = '/home/alexzh/' + self.addrs[i] + '_randtx'
xfile = '/home/alexzh/' + self.addrs[i] + '_x'
try:
with open(txfile_name, 'r'):
source_file = open(txfile_name, 'r')
try:
with open(xfile, 'r'):
xfileid = open(xfile, 'r')
except IOError:
with open(xfile, 'wb') as fout:
print 'Gnerating the repeated packet file for x sequence'
source_file.seek(0)
bytes_per_slot = int( ( SLOT_INTV - GRD_INTV ) * self.link_rate / 8 )
xpkt = source_file.read(bytes_per_slot - 64 -100)
fout.write(xpkt)
except IOError:
with open(txfile_name, 'wb') as fout:
print 'Generating Random binary file.... waiting'
fout.write(os.urandom(1280000000)) #generate a file of 8M random data
print '1.28G random binary file genearted'
def __init__(self, demodulator, rx_callback, options):
gr.top_block.__init__(self)
if(options.rx_freq is not None):
# Work-around to get the modulation's bits_per_symbol
args = demodulator.extract_kwargs_from_options(options)
symbol_rate = options.bitrate / demodulator(**args).bits_per_symbol()
ask_sample_rate = symbol_rate*options.samples_per_symbol
self.source = uhd_receiver(options.args, symbol_rate,
options.samples_per_symbol,
options.rx_freq, options.rx_gain,
options.spec, options.antenna,
options.verbose)
options.samples_per_symbol = self.source._sps
self.source.u.set_center_freq(uhd.tune_request(options.rx_freq, ask_sample_rate*2), 0)
print 'In locking '
while (self.source.u.get_sensor("lo_locked").to_bool() == False):
print '.'
print 'Locked'
elif(options.from_file is not None):
sys.stderr.write(("Reading samples from '%s'.\n\n" % (options.from_file)))
self.source = gr.file_source(gr.sizeof_gr_complex, options.from_file)
else:
sys.stderr.write("No source defined, pulling samples from null source.\n\n")
self.source = gr.null_source(gr.sizeof_gr_complex)
# Set up receive path
# do this after for any adjustments to the options that may
# occur in the sinks (specifically the UHD sink)
self.rxpath = receive_path(demodulator, rx_callback, options)
self.connect(self.source, self.rxpath)
self.connect(self.source, gr.file_sink(gr.sizeof_gr_complex, "benchmark_sensing.dat"))
self.timer = threading.Timer(1, self.start_streaming)
def setup_usrp_sources(self):
print 'setup_usrp_sources'
self.rcvs = []
for i in range(self.n_devices):
self.rcvs.append(uhd.usrp_source(self.addrs[i],
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
)
if(self._node_type == CLUSTER_NODE):
self.rcvs[i].set_start_on_demand() # the sensor will start sensing onmand
if self.rcvs[i].get_time_source(0) == "none":
self.rcvs[i].set_time_source("mimo", 0) # Set the time source without GPS to MIMO cable
self.rcvs[i].set_clock_source("mimo",0)
else:
self.rcvs[i].set_clock_source("external", 0)
self.rcvs[i].set_samp_rate(self.sample_rate)
#self.rcvs[i].set_center_freq(self.center_freq, 0)
self.rcvs[i].set_center_freq(uhd.tune_request(self.center_freq, self.sample_rate*12), 0)
if(self.rx_gain):
self.rcvs[i].set_gain(self.rx_gain, 0)
self.rcvs[i].set_antenna("RX2", 0)
def __init__(self, lo_offset_freq=1e6, threshold_dB=-70, RF=2.49e9, DC_filter_num_elements=4, speed_samp_rate=1, samp_rate=1e6, highpass_cutoff_freq=0, lowpass_cutoff_freq=1700, fft_len=pow(2,20), samp_rate_sink=8000, angle=0, tx_amp=1, rx_gain=30.5):
grc_wxgui.top_block_gui.__init__(self, title="CW Radar Single Target")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.lo_offset_freq = lo_offset_freq
self.threshold_dB = threshold_dB
self.RF = RF
self.DC_filter_num_elements = DC_filter_num_elements
self.speed_samp_rate = speed_samp_rate
self.samp_rate = samp_rate
self.highpass_cutoff_freq = highpass_cutoff_freq
self.lowpass_cutoff_freq = lowpass_cutoff_freq
self.fft_len = fft_len
self.samp_rate_sink = samp_rate_sink
self.angle = angle
self.tx_amp = tx_amp
self.rx_gain = rx_gain
##################################################
# Variables
##################################################
self.target_speed = target_speed = 0
self.target_direction = target_direction = 0
self.tx_amp_tuner = tx_amp_tuner = tx_amp
self.threshold_dB_tuner = threshold_dB_tuner = threshold_dB
self.speed_textbox = speed_textbox = target_speed
self.rx_gain_tuner = rx_gain_tuner = rx_gain
self.lowpass_cutoff_freq_tuner = lowpass_cutoff_freq_tuner = lowpass_cutoff_freq
self.highpass_cutoff_freq_tuner = highpass_cutoff_freq_tuner = highpass_cutoff_freq
self.direction_textbox = direction_textbox = target_direction
self.angle_tuner = angle_tuner = angle
self.RF_tuner = RF_tuner = RF
##################################################
# Blocks
##################################################
_tx_amp_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._tx_amp_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_tx_amp_tuner_sizer,
value=self.tx_amp_tuner,
callback=self.set_tx_amp_tuner,
label="TX Signal Amp",
converter=forms.float_converter(),
proportion=0,
)
self._tx_amp_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_tx_amp_tuner_sizer,
value=self.tx_amp_tuner,
callback=self.set_tx_amp_tuner,
minimum=0,
maximum=1,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_tx_amp_tuner_sizer, 0, 17, 1, 26)
_threshold_dB_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._threshold_dB_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_threshold_dB_tuner_sizer,
value=self.threshold_dB_tuner,
callback=self.set_threshold_dB_tuner,
label="Detected Target Threshold (dB)",
converter=forms.float_converter(),
proportion=0,
)
self._threshold_dB_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_threshold_dB_tuner_sizer,
value=self.threshold_dB_tuner,
callback=self.set_threshold_dB_tuner,
minimum=-90,
maximum=-30,
num_steps=60,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_threshold_dB_tuner_sizer, 2, 0, 1, 17)
self.speed_probe = blocks.probe_signal_f()
_rx_gain_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._rx_gain_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_rx_gain_tuner_sizer,
value=self.rx_gain_tuner,
callback=self.set_rx_gain_tuner,
label="USRP RX Gain (dB)",
converter=forms.float_converter(),
proportion=0,
)
self._rx_gain_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_rx_gain_tuner_sizer,
value=self.rx_gain_tuner,
callback=self.set_rx_gain_tuner,
minimum=0,
maximum=30.5 + 62,
num_steps=185,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_rx_gain_tuner_sizer, 0, 0, 1, 17)
self.notebook = self.notebook = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "FFT CW Doppler Radar Receiver")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "Frequency/Time CW Doppler Radar Receiver")
self.notebook.AddPage(grc_wxgui.Panel(self.notebook), "FFT CW Doppler Radar Receiver Full Spectrum")
self.GridAdd(self.notebook, 5, 0, 13, 75)
_lowpass_cutoff_freq_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._lowpass_cutoff_freq_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_lowpass_cutoff_freq_tuner_sizer,
value=self.lowpass_cutoff_freq_tuner,
callback=self.set_lowpass_cutoff_freq_tuner,
label="Lowpass Cutoff Frequency (Hz)",
converter=forms.float_converter(),
proportion=0,
)
self._lowpass_cutoff_freq_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_lowpass_cutoff_freq_tuner_sizer,
value=self.lowpass_cutoff_freq_tuner,
callback=self.set_lowpass_cutoff_freq_tuner,
minimum=0,
maximum=3000,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_lowpass_cutoff_freq_tuner_sizer, 1, 43, 1, 32)
_highpass_cutoff_freq_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._highpass_cutoff_freq_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_highpass_cutoff_freq_tuner_sizer,
value=self.highpass_cutoff_freq_tuner,
callback=self.set_highpass_cutoff_freq_tuner,
label="High-Pass Cutoff Frequency (Hz)",
converter=forms.float_converter(),
proportion=0,
)
self._highpass_cutoff_freq_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_highpass_cutoff_freq_tuner_sizer,
value=self.highpass_cutoff_freq_tuner,
callback=self.set_highpass_cutoff_freq_tuner,
minimum=0,
maximum=1600,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_highpass_cutoff_freq_tuner_sizer, 0, 43, 1, 32)
self.direction_probe = blocks.probe_signal_i()
_angle_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._angle_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_angle_tuner_sizer,
value=self.angle_tuner,
callback=self.set_angle_tuner,
label="Angle of Approach of the Target (Deg)",
converter=forms.float_converter(),
proportion=0,
)
self._angle_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_angle_tuner_sizer,
value=self.angle_tuner,
callback=self.set_angle_tuner,
minimum=0,
maximum=89,
num_steps=890,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_angle_tuner_sizer, 1, 17, 1, 26)
_RF_tuner_sizer = wx.BoxSizer(wx.VERTICAL)
self._RF_tuner_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_RF_tuner_sizer,
value=self.RF_tuner,
callback=self.set_RF_tuner,
label="Radar Frequency (Hz)",
converter=forms.float_converter(),
proportion=0,
)
self._RF_tuner_slider = forms.slider(
parent=self.GetWin(),
sizer=_RF_tuner_sizer,
value=self.RF_tuner,
callback=self.set_RF_tuner,
minimum=2.4e9,
maximum=2.5e9,
num_steps=1000,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.GridAdd(_RF_tuner_sizer, 1, 0, 1, 17)
self.wxgui_waterfallsink = waterfallsink2.waterfall_sink_c(
self.notebook.GetPage(1).GetWin(),
baseband_freq=0,
dynamic_range=100,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate_sink,
fft_size=1024,
fft_rate=100,
average=False,
avg_alpha=None,
title="Time/Frequency CW Doppler Radar",
win=window.blackmanharris,
)
self.notebook.GetPage(1).Add(self.wxgui_waterfallsink.win)
self.wxgui_fftsink2_full_spectrum = fftsink2.fft_sink_c(
self.notebook.GetPage(2).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=4096,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT CW Doppler Radar Receiver Full Spectrum",
peak_hold=False,
win=window.blackmanharris,
)
self.notebook.GetPage(2).Add(self.wxgui_fftsink2_full_spectrum.win)
self.wxgui_fftsink = fftsink2.fft_sink_c(
self.notebook.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate_sink,
fft_size=1024,
fft_rate=100,
average=False,
avg_alpha=None,
title="FFT CW Doppler Radar Receiver ",
peak_hold=False,
win=window.blackmanharris,
)
self.notebook.GetPage(0).Add(self.wxgui_fftsink.win)
self.usrp_transmitter = uhd.usrp_sink(
",".join(('addr=192.168.10.2', "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.usrp_transmitter.set_clock_source("internal", 0)
self.usrp_transmitter.set_samp_rate(samp_rate)
self.usrp_transmitter.set_center_freq(RF_tuner, 0)
self.usrp_transmitter.set_gain(0, 0)
self.usrp_transmitter.set_antenna('TX/RX', 0)
self.usrp_receiver = uhd.usrp_source(
",".join(('addr=192.168.10.3', "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.usrp_receiver.set_clock_source("mimo", 0)
self.usrp_receiver.set_time_source("mimo", 0)
self.usrp_receiver.set_samp_rate(samp_rate)
self.usrp_receiver.set_center_freq(uhd.tune_request(RF_tuner, lo_offset_freq), 0)
self.usrp_receiver.set_gain(rx_gain_tuner, 0)
self.usrp_receiver.set_antenna("J1", 0)
self.usrp_receiver.set_bandwidth(15e6, 0)
def _target_speed_probe():
while True:
val = self.speed_probe.level()
try:
self.set_target_speed(val)
except AttributeError:
pass
time.sleep(1.0 / (2))
_target_speed_thread = threading.Thread(target=_target_speed_probe)
_target_speed_thread.daemon = True
_target_speed_thread.start()
def _target_direction_probe():
while True:
val = self.direction_probe.level()
try:
self.set_target_direction(val)
except AttributeError:
pass
time.sleep(1.0 / (2))
_target_direction_thread = threading.Thread(target=_target_direction_probe)
_target_direction_thread.daemon = True
_target_direction_thread.start()
self._speed_textbox_text_box = forms.text_box(
parent=self.GetWin(),
value=self.speed_textbox,
callback=self.set_speed_textbox,
label="Target Speed (Kph)",
converter=forms.float_converter(),
)
self.GridAdd(self._speed_textbox_text_box, 3, 0, 1, 17)
self.rational_resampler = filter.rational_resampler_ccc(
interpolation=1,
decimation=int(samp_rate/samp_rate_sink),
taps=None,
fractional_bw=None,
)
self.fft_vxx_0 = fft.fft_vcc(fft_len, True, (window.blackmanharris(fft_len)), True, 1)
self._direction_textbox_text_box = forms.text_box(
parent=self.GetWin(),
value=self.direction_textbox,
callback=self.set_direction_textbox,
label="Target Direction",
converter=forms.str_converter(),
)
self.GridAdd(self._direction_textbox_text_box, 4, 0, 1, 17)
self.cwradar_vector_flip_ff = cwradar.vector_flip_ff(fft_len/2)
self.cwradar_doppler_velocity_single_target_ff_0 = cwradar.doppler_velocity_single_target_ff(fft_len/2, samp_rate, RF_tuner, threshold_dB_tuner, angle_tuner, lowpass_cutoff_freq_tuner, highpass_cutoff_freq_tuner)
self.complex_to_mag = blocks.complex_to_mag(fft_len)
self.blocks_vector_to_stream_0_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_len)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, fft_len)
self.blocks_stream_to_vector_1_0 = blocks.stream_to_vector(gr.sizeof_float*1, fft_len/2)
self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_float*1, fft_len/2)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, fft_len)
self.blocks_keep_m_in_n_0_0 = blocks.keep_m_in_n(gr.sizeof_float, fft_len/2, fft_len, fft_len/2)
self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_float, fft_len/2, fft_len, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 0, tx_amp_tuner, 0)
self.DC_filter_0 = blocks.multiply_const_vff(([0]*DC_filter_num_elements+[1]*((fft_len/2)-DC_filter_num_elements)))
self.DC_filter = blocks.multiply_const_vff(([0]*DC_filter_num_elements+[1]*((fft_len/2)-DC_filter_num_elements)))
##################################################
# Connections
##################################################
self.connect((self.blocks_vector_to_stream_0_0, 0), (self.blocks_keep_m_in_n_0_0, 0))
self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_stream_to_vector_1, 0))
self.connect((self.blocks_keep_m_in_n_0_0, 0), (self.blocks_stream_to_vector_1_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_keep_m_in_n_0, 0))
self.connect((self.blocks_stream_to_vector_1_0, 0), (self.DC_filter_0, 0))
self.connect((self.blocks_stream_to_vector_1, 0), (self.cwradar_vector_flip_ff, 0))
self.connect((self.cwradar_vector_flip_ff, 0), (self.DC_filter, 0))
self.connect((self.rational_resampler, 0), (self.wxgui_waterfallsink, 0))
self.connect((self.rational_resampler, 0), (self.wxgui_fftsink, 0))
self.connect((self.fft_vxx_0, 0), (self.complex_to_mag, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.complex_to_mag, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.complex_to_mag, 0), (self.blocks_vector_to_stream_0_0, 0))
self.connect((self.DC_filter_0, 0), (self.cwradar_doppler_velocity_single_target_ff_0, 1))
self.connect((self.DC_filter, 0), (self.cwradar_doppler_velocity_single_target_ff_0, 0))
self.connect((self.cwradar_doppler_velocity_single_target_ff_0, 0), (self.speed_probe, 0))
self.connect((self.cwradar_doppler_velocity_single_target_ff_0, 1), (self.direction_probe, 0))
self.connect((self.usrp_receiver, 0), (self.wxgui_fftsink2_full_spectrum, 0))
self.connect((self.usrp_receiver, 0), (self.rational_resampler, 0))
self.connect((self.usrp_receiver, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.usrp_transmitter, 0))
def set_freq_l1(self, freq_l1):
self.freq_l1 = freq_l1
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.freq_l1, self.lo_off), 0)
def set_lo_off(self, lo_off):
self.lo_off = lo_off
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(self.freq_l1, self.lo_off), 0)
def set_tx_offset(self, tx_offset):
self.tx_offset = tx_offset
self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(self.tx_freq+self.tx_correct, self.tx_offset), 0)
def __init__(self, addr="127.0.0.1", alpha=0.5, bb_gain=0.65, port="4000", samps_per_symb=4, tx_correct=0, tx_freq=2402e6, tx_gain=20, samp_rate=100e3, tx_offset=50e3):
gr.top_block.__init__(self, "Tx Scram Sock")
##################################################
# Parameters
##################################################
self.addr = addr
self.alpha = alpha
self.bb_gain = bb_gain
self.port = port
self.samps_per_symb = samps_per_symb
self.tx_correct = tx_correct
self.tx_freq = tx_freq
self.tx_gain = tx_gain
self.samp_rate = samp_rate
self.tx_offset = tx_offset
##################################################
# Blocks
##################################################
self.vtgs_mult_scrambler_0 = vtgs.mult_scrambler(17, 0x3FFFF)
self.vtgs_ao40_encoder_0 = vtgs.ao40_encoder(False, 449838109)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_time_source("gpsdo", 0)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(tx_freq+tx_correct, tx_offset), 0)
self.uhd_usrp_sink_0.set_gain(tx_gain, 0)
self.uhd_usrp_sink_0.set_antenna("TX/RX", 0)
self.digital_map_bb_0 = digital.map_bb((1,0))
self.digital_dxpsk_mod_0 = digital.dbpsk_mod(
samples_per_symbol=samps_per_symb,
excess_bw=alpha,
mod_code="gray",
verbose=False,
log=False)
self.blocks_stream_mux_0 = blocks.stream_mux(gr.sizeof_char*1, (384,5232,384))
self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", addr, port, 10000, False)
self.blocks_pack_k_bits_bb_0 = blocks.pack_k_bits_bb(8)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((bb_gain, ))
self.analog_random_source_x_0 = blocks.vector_source_b(map(int, numpy.random.randint(0, 1, 1000)), True)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_socket_pdu_0, 'pdus'), (self.vtgs_ao40_encoder_0, 'in'))
self.connect((self.analog_random_source_x_0, 0), (self.blocks_stream_mux_0, 0))
self.connect((self.analog_random_source_x_0, 0), (self.blocks_stream_mux_0, 2))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.uhd_usrp_sink_0, 0))
self.connect((self.blocks_pack_k_bits_bb_0, 0), (self.digital_dxpsk_mod_0, 0))
self.connect((self.blocks_stream_mux_0, 0), (self.digital_map_bb_0, 0))
self.connect((self.digital_dxpsk_mod_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.digital_map_bb_0, 0), (self.vtgs_mult_scrambler_0, 0))
self.connect((self.vtgs_ao40_encoder_0, 0), (self.blocks_stream_mux_0, 1))
self.connect((self.vtgs_mult_scrambler_0, 0), (self.blocks_pack_k_bits_bb_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.raw_samp_rate = raw_samp_rate = 2e6
self.decimation = decimation = 8
self.sym_rate = sym_rate = 2400
self.samp_rate = samp_rate = raw_samp_rate/decimation
self.half_dev = half_dev = 40e3
self.freq_offset = freq_offset = 500
self.bin_width = bin_width = 10e3
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(raw_samp_rate)
self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(450E6, 8E6), 0)
self.uhd_usrp_source_0.set_gain(30, 0)
self.low_pass_filter_1 = filter.fir_filter_fff(1, firdes.low_pass(
1, samp_rate, 10e3, 300, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0 = filter.fir_filter_ccf(decimation, firdes.low_pass(
2, raw_samp_rate, 250e3, 50e3, firdes.WIN_HAMMING, 6.76))
self.blocks_sub_xx_0 = blocks.sub_ff(1)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*1)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, "samples", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_1 = blocks.complex_to_mag_squared(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.blks2_valve_0 = grc_blks2.valve(item_size=gr.sizeof_gr_complex*1, open=bool(False))
self.band_pass_filter_0_0 = filter.fir_filter_ccc(1, firdes.complex_band_pass(
1, samp_rate, -half_dev-bin_width/2+freq_offset, -half_dev+bin_width/2+freq_offset, 500, firdes.WIN_HAMMING, 6.76))
self.band_pass_filter_0 = filter.fir_filter_ccc(1, firdes.complex_band_pass(
1, samp_rate, +half_dev-bin_width/2+freq_offset, +half_dev+bin_width/2+freq_offset, 500, firdes.WIN_HAMMING, 6.76))
##################################################
# Connections
##################################################
self.connect((self.low_pass_filter_0, 0), (self.band_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.band_pass_filter_0_0, 0))
self.connect((self.band_pass_filter_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.band_pass_filter_0_0, 0), (self.blocks_complex_to_mag_squared_1, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_sub_xx_0, 0))
self.connect((self.blocks_complex_to_mag_squared_1, 0), (self.blocks_sub_xx_0, 1))
self.connect((self.blocks_sub_xx_0, 0), (self.low_pass_filter_1, 0))
self.connect((self.uhd_usrp_source_0, 0), (self.blks2_valve_0, 0))
self.connect((self.blks2_valve_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_1, 0), (self.blocks_file_sink_0, 0))
self.connect((self.low_pass_filter_1, 0), (self.blocks_null_sink_0, 0))
def setup_usrp(self, ctor, args, cpu_format='fc32'):
"""
Instantiate a USRP object; takes care of all kinds of corner cases and settings.
Pop it and some args onto the class that calls this.
"""
self.channels = args.channels
self.cpu_format = cpu_format
# Create a UHD device object:
self.usrp = ctor(
device_addr=args.args,
stream_args=uhd.stream_args(
cpu_format,
args.otw_format,
args=args.stream_args,
channels=self.channels,
)
)
# Set the subdevice spec:
self.spec = self.normalize_sel("mboards", "subdev",
self.usrp.get_num_mboards(), args.spec)
if self.spec:
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.set_subdev_spec(self.spec[mb_idx], mb_idx)
# Set the clock and/or time source:
if args.clock_source is not None:
self.clock_source = self.normalize_sel("mboards", "clock-source",
self.usrp.get_num_mboards(), args.clock_source)
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.set_clock_source(self.clock_source[mb_idx], mb_idx)
if args.time_source is not None:
self.time_source = self.normalize_sel("mboards", "time-source",
self.usrp.get_num_mboards(), args.time_source)
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.set_time_source(self.time_source[mb_idx], mb_idx)
# Sampling rate:
self.usrp.set_samp_rate(args.samp_rate)
self.samp_rate = self.usrp.get_samp_rate()
self.vprint("Using sampling rate: {rate}".format(rate=self.samp_rate))
# Set the antenna:
self.antenna = self.normalize_sel("channels", "antenna", len(args.channels), args.antenna)
if self.antenna is not None:
for i, chan in enumerate(self.channels):
if not self.antenna[i] in self.usrp.get_antennas(i):
print("[ERROR] {} is not a valid antenna name for this USRP device!".format(self.antenna[i]))
exit(1)
self.usrp.set_antenna(self.antenna[i], i)
self.vprint("[{prefix}] Channel {chan}: Using antenna {ant}.".format(
prefix=self.prefix, chan=chan, ant=self.usrp.get_antenna(i)
))
self.antenna = self.usrp.get_antenna(0)
# Set receive daughterboard gain:
self.set_gain(args.gain)
self.gain_range = self.usrp.get_gain_range(0)
# Set frequency (tune request takes lo_offset):
if hasattr(args, 'lo_offset') and args.lo_offset is not None:
treq = uhd.tune_request(args.freq, args.lo_offset)
else:
treq = uhd.tune_request(args.freq)
self.has_lo_sensor = 'lo_locked' in self.usrp.get_sensor_names()
# Set LO export and LO source operation
if (args.lo_export is not None) and (args.lo_source is not None):
self.lo_source = self.normalize_sel("channels", "lo-source", len(self.channels), args.lo_source)
self.lo_export = self.normalize_sel("channels", "lo-export", len(self.channels), args.lo_export)
for chan, lo_source, lo_export in zip(self.channels, self.lo_source, self.lo_export):
if (lo_source == "None") or (lo_export == "None"):
continue
if lo_export == "True":
#If channel is LO source set frequency and store response
self.usrp.set_lo_export_enabled(True, uhd.ALL_LOS, chan)
if lo_source == "internal":
self.lo_source_channel = chan
tune_resp = self.usrp.set_center_freq(treq,chan)
self.usrp.set_lo_source(lo_source, uhd.ALL_LOS,chan)
# Use lo source tune response to tune dsp_freq on remaining channels
if getattr(args, 'lo_offset', None) is not None:
treq = uhd.tune_request(target_freq=args.freq, rf_freq=args.freq+args.lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
else:
treq = uhd.tune_request(target_freq=args.freq, rf_freq=args.freg, rf_freq_policy=uhd.tune_request.POLICY_MANUAL,
dsp_freq=tune_resp.actual_dsp_freq,
dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)
for chan in args.channels:
if chan == self.lo_source_channel:
continue
self.usrp.set_center_freq(treq,chan)
# Make sure tuning is synched:
command_time_set = False
if len(self.channels) > 1:
if args.sync == 'pps':
self.usrp.set_time_unknown_pps(uhd.time_spec())
cmd_time = self.usrp.get_time_now() + uhd.time_spec(COMMAND_DELAY)
try:
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.set_command_time(cmd_time, mb_idx)
command_time_set = True
except RuntimeError:
sys.stderr.write('[{prefix}] [WARNING] Failed to set command times.\n'.format(prefix=self.prefix))
for i, chan in enumerate(self.channels):
self.tr = self.usrp.set_center_freq(treq, i)
if self.tr == None:
sys.stderr.write('[{prefix}] [ERROR] Failed to set center frequency on channel {chan}\n'.format(
prefix=self.prefix, chan=chan
))
exit(1)
if command_time_set:
for mb_idx in xrange(self.usrp.get_num_mboards()):
self.usrp.clear_command_time(mb_idx)
self.vprint("Syncing channels...".format(prefix=self.prefix))
time.sleep(COMMAND_DELAY)
self.freq = self.usrp.get_center_freq(0)
if args.show_async_msg:
self.async_msgq = gr.msg_queue(0)
self.async_src = uhd.amsg_source("", self.async_msgq)
self.async_rcv = gru.msgq_runner(self.async_msgq, self.async_callback)
def set_lo_off_user(self, lo_off_user):
self.lo_off_user = lo_off_user
self._lo_off_user_text_box.set_value(self.lo_off_user)
self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(self.nominal_uplink_freq_user,self.lo_off_user), 0)
def __init__(self, sym_rate=256, samp_per_sym=256, nominal_uplink_freq=2041.95e6*0 + 2041.9479e6 + 1e6*0, lo_off=5e6 * 0, tx_gain=15*0 + 13.5*0, backoff=0.150*0 + (0.6+0.1)*0 + 1e-3, record_path='/media/balint/PATRIOT/ICE/TX/'):
grc_wxgui.top_block_gui.__init__(self, title="Uplink")
##################################################
# Parameters
##################################################
self.sym_rate = sym_rate
self.samp_per_sym = samp_per_sym
self.nominal_uplink_freq = nominal_uplink_freq
self.lo_off = lo_off
self.tx_gain = tx_gain
self.backoff = backoff
self.record_path = record_path
##################################################
# Variables
##################################################
self.time_format = time_format = "%Y-%d-%m_%H-%M-%S"
self.time_now = time_now = time.strftime(time_format)
self.samp_rate = samp_rate = 250000
self.pre_resamp_rate = pre_resamp_rate = sym_rate * samp_per_sym
self.f1 = f1 = 9000.0
self.f0 = f0 = 7500.0
self.resamp_rate = resamp_rate = float(samp_rate)/float(pre_resamp_rate)
self.pm = pm = 1.2*0 + 1.0
self.nominal_uplink_freq_chooser = nominal_uplink_freq_chooser = nominal_uplink_freq
self.manual_doppler = manual_doppler = 0
self.file_name = file_name = time_now + ".mcfile"
self.doppler = doppler = 0
self.deviation = deviation = (f1 - f0) / 2.0
self.tx_gain_user = tx_gain_user = tx_gain
self.subcarrier_freq = subcarrier_freq = f0 + deviation
self.source = source = 'external'
self.pm_txt = pm_txt = pm
self.nominal_uplink_freq_user = nominal_uplink_freq_user = nominal_uplink_freq_chooser
self.lo_off_user = lo_off_user = lo_off
self.length_mul = length_mul = float(samp_per_sym) * resamp_rate
self.invert = invert = 1
self.final_record_path = final_record_path = os.path.join(record_path, file_name)
self.final_doppler = final_doppler = doppler + manual_doppler
self.backoff_user = backoff_user = backoff
##################################################
# Blocks
##################################################
_tx_gain_user_sizer = wx.BoxSizer(wx.VERTICAL)
self._tx_gain_user_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_tx_gain_user_sizer,
value=self.tx_gain_user,
callback=self.set_tx_gain_user,
label="TX Gain",
converter=forms.float_converter(),
proportion=0,
)
self._tx_gain_user_slider = forms.slider(
parent=self.GetWin(),
sizer=_tx_gain_user_sizer,
value=self.tx_gain_user,
callback=self.set_tx_gain_user,
minimum=0,
maximum=32,
num_steps=32,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_tx_gain_user_sizer)
self._nominal_uplink_freq_user_text_box = forms.text_box(
parent=self.GetWin(),
value=self.nominal_uplink_freq_user,
callback=self.set_nominal_uplink_freq_user,
label="Nominal Uplink Freq",
converter=forms.float_converter(),
)
self.Add(self._nominal_uplink_freq_user_text_box)
self.nb = self.nb = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Output FFT")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Input FFT")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Input Phase/Mag")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "Mod Clk/Data")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "PM Output Scope")
self.nb.AddPage(grc_wxgui.Panel(self.nb), "PM Input")
self.Add(self.nb)
self._lo_off_user_text_box = forms.text_box(
parent=self.GetWin(),
value=self.lo_off_user,
callback=self.set_lo_off_user,
label="LO Offset",
converter=forms.float_converter(),
)
self.Add(self._lo_off_user_text_box)
self._final_doppler_static_text = forms.static_text(
parent=self.GetWin(),
value=self.final_doppler,
callback=self.set_final_doppler,
label="Final Doppler",
converter=forms.float_converter(),
)
self.Add(self._final_doppler_static_text)
self._doppler_text_box = forms.text_box(
parent=self.GetWin(),
value=self.doppler,
callback=self.set_doppler,
label="Doppler Shift",
converter=forms.float_converter(),
)
self.Add(self._doppler_text_box)
_backoff_user_sizer = wx.BoxSizer(wx.VERTICAL)
self._backoff_user_text_box = forms.text_box(
parent=self.GetWin(),
sizer=_backoff_user_sizer,
value=self.backoff_user,
callback=self.set_backoff_user,
label="Backoff",
converter=forms.float_converter(),
proportion=0,
)
self._backoff_user_slider = forms.slider(
parent=self.GetWin(),
sizer=_backoff_user_sizer,
value=self.backoff_user,
callback=self.set_backoff_user,
minimum=0,
maximum=1,
num_steps=100,
style=wx.SL_HORIZONTAL,
cast=float,
proportion=1,
)
self.Add(_backoff_user_sizer)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("", 52003), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
threading.Thread(target=self.xmlrpc_server_0.serve_forever).start()
self.wxgui_scopesink2_2 = scopesink2.scope_sink_f(
self.nb.GetPage(5).GetWin(),
title="Scope Plot",
sample_rate=pre_resamp_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb.GetPage(5).Add(self.wxgui_scopesink2_2.win)
self.wxgui_scopesink2_1 = scopesink2.scope_sink_c(
self.nb.GetPage(4).GetWin(),
title="Scope Plot",
sample_rate=samp_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb.GetPage(4).Add(self.wxgui_scopesink2_1.win)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.nb.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=samp_rate,
fft_size=256,
fft_rate=10,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False, fft_in=False,
always_run=False,
fft_out=False,
)
self.nb.GetPage(0).Add(self.wxgui_fftsink2_0.win)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("serial=F4A7C3", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
"",
True,
)
self.uhd_usrp_sink_0.set_clock_source(source, 0)
self.uhd_usrp_sink_0.set_time_source(source, 0)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(nominal_uplink_freq_user,lo_off_user), 0)
self.uhd_usrp_sink_0.set_gain(tx_gain*0 + tx_gain_user, 0)
self.uhd_usrp_sink_0.set_antenna('TX/RX', 0)
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=int(samp_rate),
decimation=int(pre_resamp_rate),
taps=None,
fractional_bw=None,
)
self._pm_txt_static_text = forms.static_text(
parent=self.GetWin(),
value=self.pm_txt,
callback=self.set_pm_txt,
label="Phase Moduation Index",
converter=forms.float_converter(),
)
self.Add(self._pm_txt_static_text)
self._nominal_uplink_freq_chooser_chooser = forms.drop_down(
parent=self.GetWin(),
value=self.nominal_uplink_freq_chooser,
callback=self.set_nominal_uplink_freq_chooser,
label="Nomial Uplink Frequency",
choices=[2041.9479e6, 2090.66e6],
labels=['B: 2041.9479', 'A: 2090.66'],
)
self.Add(self._nominal_uplink_freq_chooser_chooser)
self._manual_doppler_text_box = forms.text_box(
parent=self.GetWin(),
value=self.manual_doppler,
callback=self.set_manual_doppler,
label="Manual Doppler",
converter=forms.float_converter(),
)
self.Add(self._manual_doppler_text_box)
self.mac_burst_tagger_0 = mac.burst_tagger('packet_len', length_mul, 256, 32*0 + 256, True, False)
self.clock_and_data = scopesink2.scope_sink_c(
self.nb.GetPage(3).GetWin(),
title="Scope Plot",
sample_rate=pre_resamp_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb.GetPage(3).Add(self.clock_and_data.win)
self.carrier = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, doppler*0 + final_doppler, 0*backoff + backoff_user, 0)
self.blocks_vector_source_x_0 = blocks.vector_source_f(tuple([1] * (samp_per_sym/4) + [0] * (samp_per_sym/4) + [0] * (samp_per_sym/4) + [1] * (samp_per_sym/4)), True, 1, [])
self.blocks_socket_pdu_0 = blocks.socket_pdu("TCP_SERVER", "", "52002", 10000, False)
self.blocks_repeat_0 = blocks.repeat(gr.sizeof_float*1, samp_per_sym)
self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len", 1)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*1)
self.blocks_multiply_xx_1 = blocks.multiply_vcc(1)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_multiply_const_vxx_1_0 = blocks.multiply_const_vff((2.0/3, ))
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff((2, ))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((invert, ))
self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.cons(pmt.to_pmt({'ignore': True}), pmt.init_u8vector(1, 1*[0])), 0)
self.blocks_float_to_complex_2 = blocks.float_to_complex(1)
self.blocks_float_to_complex_1 = blocks.float_to_complex(1)
self.blocks_file_meta_sink_0 = blocks.file_meta_sink(gr.sizeof_gr_complex*1, final_record_path, samp_rate, 1, blocks.GR_FILE_FLOAT, True, 1000000, "", True)
self.blocks_file_meta_sink_0.set_unbuffered(False)
self.blocks_complex_to_float_0 = blocks.complex_to_float(1)
self.blocks_char_to_float_0 = blocks.char_to_float(1, 1)
self.blocks_add_const_vxx_1_0 = blocks.add_const_vff((1.0/3, ))
self.blocks_add_const_vxx_1 = blocks.add_const_vff((-1, ))
self.binary_to_pdu0 = isee3.binary_to_pdu()
self.analog_sig_source_x_0 = analog.sig_source_c(pre_resamp_rate, analog.GR_COS_WAVE, subcarrier_freq, 1/1.333, 0)
self.analog_phase_modulator_fc_1 = analog.phase_modulator_fc(pm / (2.0*0 + 1))
self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc(float(deviation) / float(pre_resamp_rate) * math.pi*2.0)
##################################################
# Connections
##################################################
self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_char_to_float_0, 0))
self.connect((self.blocks_char_to_float_0, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.blocks_add_const_vxx_1, 0))
self.connect((self.blocks_add_const_vxx_1, 0), (self.blocks_repeat_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_complex_to_float_0, 0))
self.connect((self.analog_frequency_modulator_fc_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_multiply_const_vxx_1_0, 0), (self.blocks_add_const_vxx_1_0, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_multiply_const_vxx_1_0, 0))
self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_float_to_complex_2, 0))
self.connect((self.blocks_float_to_complex_1, 0), (self.clock_and_data, 0))
self.connect((self.blocks_multiply_xx_1, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.carrier, 0), (self.blocks_multiply_xx_1, 1))
self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_float_to_complex_1, 1))
self.connect((self.blocks_repeat_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.analog_frequency_modulator_fc_0, 0))
self.connect((self.blocks_complex_to_float_0, 0), (self.analog_phase_modulator_fc_1, 0))
self.connect((self.blocks_complex_to_float_0, 1), (self.blocks_null_sink_0, 0))
self.connect((self.blocks_complex_to_float_0, 0), (self.wxgui_scopesink2_2, 0))
self.connect((self.blocks_add_const_vxx_1_0, 0), (self.blocks_float_to_complex_2, 1))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_float_to_complex_1, 0))
self.connect((self.blocks_float_to_complex_2, 0), (self.blocks_multiply_xx_0, 2))
self.connect((self.mac_burst_tagger_0, 0), (self.uhd_usrp_sink_0, 0))
self.connect((self.blocks_multiply_xx_1, 0), (self.mac_burst_tagger_0, 0))
self.connect((self.blocks_multiply_xx_1, 0), (self.wxgui_scopesink2_1, 0))
self.connect((self.analog_phase_modulator_fc_1, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.blocks_multiply_xx_1, 0))
self.connect((self.mac_burst_tagger_0, 0), (self.blocks_file_meta_sink_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.binary_to_pdu0, "pdu_out", self.blocks_pdu_to_tagged_stream_0, "pdus")
self.msg_connect(self.blocks_socket_pdu_0, "pdus", self.binary_to_pdu0, "binary_in")
self.msg_connect(self.blocks_message_strobe_0_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus")
self.msg_connect(self.uhd_usrp_sink_0, "ctl", self.blocks_message_strobe_0_0, "trigger")
def set_lo_offset_freq(self, lo_offset_freq):
self.lo_offset_freq = lo_offset_freq
self.usrp_receiver.set_center_freq(uhd.tune_request(self.RF_tuner, self.lo_offset_freq), 0)
def __init__(self):
gr.top_block.__init__(self)
parser=OptionParser(option_class=eng_option)
parser.add_option("-a", "--args", type="string", default="",
help="UHD device address args [default=%default]")
parser.add_option("", "--spec", type="string", default="A:0 A:0",
help="Subdevice of UHD device where appropriate")
parser.add_option("-A", "--antenna", type="string", default=None,
help="select Rx Antenna where appropriate")
parser.add_option("", "--f1", type="eng_float", default=100.7e6,
help="set 1st station frequency to FREQ", metavar="FREQ")
parser.add_option("", "--f2", type="eng_float", default=102.5e6,
help="set 2nd station freq to FREQ", metavar="FREQ")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="set gain in dB (default is midpoint)")
parser.add_option("-O", "--audio-output", type="string", default="default",
help="pcm device name. E.g., hw:0,0 or surround51 or /dev/dsp")
parser.add_option("", "--freq-min", type="eng_float", default=87.9e6,
help="Set a minimum frequency [default=%default]")
parser.add_option("", "--freq-max", type="eng_float", default=108.1e6,
help="Set a maximum frequency [default=%default]")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if abs(options.f1 - options.f2) > 5.5e6:
print "Sorry, two stations must be within 5.5MHz of each other"
raise SystemExit
f = (options.f1, options.f2)
self.vol = .1
self.state = "FREQ"
self.fm_freq_min = options.freq_min
self.fm_freq_max = options.freq_max
# build graph
stream_args = uhd.stream_args('fc32', channels=range(2))
self.u = uhd.usrp_source(device_addr=options.args, stream_args=stream_args)
# Set front end channel mapping
self.u.set_subdev_spec(options.spec)
usrp_rate = 320e3
demod_rate = 320e3
audio_rate = 32e3
audio_decim = int(demod_rate / audio_rate)
self.u.set_samp_rate(usrp_rate)
dev_rate = self.u.get_samp_rate()
# Make sure dboard can suppor the required frequencies
frange = self.u.get_freq_range()
if(frange.start() > self.fm_freq_max or frange.stop() < self.fm_freq_min):
sys.stderr.write("Radio does not support required frequency range.\n")
sys.exit(1)
# sound card as final sink
self.audio_sink = audio.sink(int(audio_rate), options.audio_output)
# taps for channel filter
nfilts = 32
chan_coeffs = optfir.low_pass (nfilts, # gain
nfilts*usrp_rate, # sampling rate
80e3, # passband cutoff
115e3, # stopband cutoff
0.1, # passband ripple
60) # stopband attenuation
rrate = usrp_rate / dev_rate
# set front end PLL to middle frequency
mid_freq = (f[0] + f[1]) / 2.0
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.get_gain_range()
options.gain = float(g.start()+g.stop())/2.0
for n in range(2):
chan_filt = blks2.pfb_arb_resampler_ccf(rrate, chan_coeffs, nfilts)
guts = blks2.wfm_rcv (demod_rate, audio_decim)
volume_control = gr.multiply_const_ff(self.vol)
#self.connect((self.di, n), chan_filt)
self.connect((self.u, n), chan_filt)
self.connect(chan_filt, guts, volume_control)
self.connect(volume_control, (self.audio_sink, n))
# Test the the requested frequencies are in range
if(f[n] < self.fm_freq_min or f[n] > self.fm_freq_max):
sys.stderr.write("Requested frequency is outside of required frequency range.\n")
sys.exit(1)
# Tune each channel by setting the RF freq to mid_freq and the
# DDC freq to f[n].
tr = uhd.tune_request(f[n], rf_freq=mid_freq,
rf_freq_policy=uhd.tune_request.POLICY_MANUAL)
self.u.set_center_freq(tr, n)
# Set gain for each channel
self.set_gain(options.gain, n)
# Set the antenna
if(options.antenna):
self.u.set_antenna(options.antenna, n)
