def freq(self, value):
# Check the input value is usable
try:
cen_freq, lo_off = value
except ValueError:
raise ValueError("Pass an iterable with two items")
if cen_freq is None:
raise TypeError("You must specify -f FREQ or --freq FREQ")
if type(cen_freq) is list:
if len(cen_freq) > 1 and not self.mimo:
raise AssertionError('freq must be a one item list or a float (SISO mode)')
elif self.mimo and len(cen_freq) != 2:
raise AssertionError('freq must be a two-item list (MIMO mode)')
elif self.mimo:
tmp_freq = cen_freq
else:
tmp_freq = cen_freq[0]
elif type(cen_freq) is not float:
raise AssertionError('freq must be a list or a float')
else:
# cen_freq is a float
tmp_freq = [cen_freq]
if lo_off is not None:
response = self.u.set_center_freq(uhd.tune_request_t(tmp_freq[0], lo_off), 0)
if self.mimo:
response1 = self.u.set_center_freq(uhd.tune_request_t(tmp_freq[1], lo_off), 1)
RT_LOGGER.i_logging("Setting freq to %s and LO-offset to %f" % (tmp_freq, lo_off), self.block_name)
else:
response = self.u.set_center_freq(tmp_freq[0], 0)
if self.mimo:
response1 = self.u.set_center_freq(tmp_freq[1], 1)
RT_LOGGER.i_logging("Setting freq to %s and no LO-offset" % tmp_freq, self.block_name)
if response is not None:
actual_freq = []
actual_freq.append(self.u.get_center_freq(0))
if actual_freq[0] != tmp_freq[0]:
RT_LOGGER.w_logging("actual freq %s does not match the expected freq %s" % (actual_freq, tmp_freq),
self.block_name)
if self.mimo:
if response1 is not None:
actual_freq.append(self.u.get_center_freq(1))
if actual_freq[1] != tmp_freq[1]:
RT_LOGGER.w_logging("actual freq %s does not match the expected freq %s" % (actual_freq, tmp_freq),
self.block_name)
else:
f_range = self.u.get_freq_range(1)
raise ValueError("expected frequency %f is out-of-range [%f, %f] in 2nd path" %
(tmp_freq[1], f_range.start(), f_range.stop()))
self._freq = actual_freq
self._lo_offset = lo_off
else:
f_range = self.u.get_freq_range()
raise ValueError("expected frequency %f is out-of-range [%f, %f]" %
(tmp_freq, f_range.start(), f_range.stop()))
def work(self,ins,outs):
n=min(len(ins[0]),len(outs[0]))
outs[0][:n]=ins[0][:n]
self.consume(0,n)
self.produce(0,n)
if(time.time()>self.start):
print "hoping"
self.uhd_control.set("tx_freq",uhd.tune_request_t(self.freq_ls[self.hop_index]))
self.hop_index=(self.hop_index+1)%len(self.freq_ls)
self.start=time.time()+5
def set_rfFreqMhz(self, rfFreqMhz):
self.rfFreqMhz = rfFreqMhz
self.uhd_usrp_sink_1.set_center_freq(uhd.tune_request_t((self.rfFreqMhz+1)*1e6, 2*self.samp_rate), 0)
self._cfg_rfFreqMhz_config = ConfigParser.ConfigParser()
self._cfg_rfFreqMhz_config.read(self.configFilePath)
if not self._cfg_rfFreqMhz_config.has_section('tuner'):
self._cfg_rfFreqMhz_config.add_section('tuner')
self._cfg_rfFreqMhz_config.set('tuner', 'freq', str(self.rfFreqMhz))
self._cfg_rfFreqMhz_config.write(open(self.configFilePath, 'w'))
self.CyberRadio_freq_msg_strobe_0.set_fManual(self.rfFreqMhz)
def __init__(self, u, center_freq, hw_dec_rate, downsample_rate, pulse_width, tari, debug_on, output_data):
gr.top_block.__init__(self)
# sample_rate = 100e6 / hw_dec_rate
sample_rate = 2e6
self.u = u
# self.u.set_decim(hw_dec_rate)
g = u.get_gain_range()
print "-----------"
self.u.set_gain(float(g.start() + g.stop()) / 4)
print "Using gain of", float(g.start() + g.stop()) / 4 , "(", g.stop(), "-", g.start(), ")"
tune_req = uhd.tune_request_t(center_freq,sample_rate)
# r = rx.set_center_freq(tune_req)
x = self.u.set_center_freq(tune_req)
if not x:
print "Couldn't set rx freq"
self.u.set_samp_rate(sample_rate)
us_per_sample = 1e6 / sample_rate * downsample_rate
print "USRP Sample Rate: "+ str(sample_rate) + " us Per Sample: " + str(us_per_sample)
# 25 Msps is too much to process. But we don't want to decimate at the USRP because we want the full band.
# We can downsample, because we don't care about aliasing.
self.downsample = gr.keep_one_in_n(gr.sizeof_gr_complex, int(downsample_rate))
self.to_mag = gr.complex_to_mag()
# For TARI = 24, PW == DELIM. So we can't do a matched filter, or everything becomes a delimiter and a zero.
# PW / 2 smooths reasonably well.
# self.smooth = gr.moving_average_ff(int(pulse_width / us_per_sample) /2 , int(pulse_width / us_per_sample) /2 )
self.smooth = gr.moving_average_ff(int(1), 1.0)
self.rd = rfid.reader_decoder(us_per_sample, tari)
if(debug_on):
# fileInfo = "_smooth1_b"
# time = strftime("%H_%M_%S", localtime())
# threshFileName = "rm_thresh_" + time + fileInfo + ".out"
# signalFileName = "rm_signal_" + time + fileInfo + ".out"
signalFileName = "rm_signal.out"
threshFileName = "rm_thresh.out"
self.sink = gr.file_sink(gr.sizeof_float, threshFileName)
# self.signal_sink = gr.file_sink(gr.sizeof_float, signalFileName)
# self.connect(self.smooth, self.signal_sink)
else:
self.sink = gr.null_sink(gr.sizeof_float)
self.connect(self.u, self.downsample, self.to_mag, self.smooth, self.rd, self.sink)
# Change to "gr.sizeof_gr_complex" if "block_x" is "rx"
file_rx_sink = gr.file_sink(gr.sizeof_gr_complex, output_data)
self.connect(self.u, file_rx_sink)
def set_center_freq(self, fc, lo_off):
'''
set the center frequency
'''
tune_request = uhd.tune_request_t(fc, lo_off)
tune_res = self.rx.set_center_freq(tune_request)
rf_freq = tune_res.actual_rf_freq
dxc_freq = 0
print("i: actual_rf_freq = " + str(rf_freq) +
"\ni: actual_dsp_freq = " + str(tune_res.actual_dsp_freq) +
"\ni: target_rf_freq = " + str(tune_res.target_rf_freq) +
"\ni: target_dsp_freq = " + str(tune_res.target_dsp_freq))
# return (rf_sink, rf_freq, dxc_freq)
def __init__(self, p, c, pw, ff, sr, br):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = sr
self.channel_select = channel_select = c
self.bit_rate = bit_rate = br
##################################################
# Blocks
##################################################
self.uhd_usrp_sink_0 = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request_t(161975000 + 50000 * c, ff), 0)
self.uhd_usrp_sink_0.set_gain(-10, 0)
self.uhd_usrp_sink_0.set_antenna("TX/RX", 0)
self.digital_gmsk_mod_0 = digital.gmsk_mod(
samples_per_symbol=int(samp_rate / bit_rate),
bt=0.4,
verbose=False,
log=False,
)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.9, ))
self.AISTX_Build_Frame_0 = AISTX.Build_Frame(p, False, True)
##################################################
# Connections
##################################################
self.connect((self.AISTX_Build_Frame_0, 0),
(self.digital_gmsk_mod_0, 0))
self.connect((self.digital_gmsk_mod_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.uhd_usrp_sink_0, 0))
def __init__(self, p, c, pw, ff, sr, br):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = sr
self.channel_select = channel_select = c
self.bit_rate = bit_rate = br
##################################################
# Blocks
##################################################
self.uhd_usrp_sink_0 = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request_t(161975000+50000*c,ff), 0)
self.uhd_usrp_sink_0.set_gain(-10, 0)
self.uhd_usrp_sink_0.set_antenna("TX/RX", 0)
self.digital_gmsk_mod_0 = digital.gmsk_mod(
samples_per_symbol=int(samp_rate/bit_rate),
bt=0.4,
verbose=False,
log=False,
)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.9, ))
self.AISTX_Build_Frame_0 = AISTX.Build_Frame(p, False, True)
##################################################
# Connections
##################################################
self.connect((self.AISTX_Build_Frame_0, 0), (self.digital_gmsk_mod_0, 0))
self.connect((self.digital_gmsk_mod_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.uhd_usrp_sink_0, 0))
def __init__(self):
gr.top_block.__init__(self)
amplitude = 30000 # 1 2150 10000
rx_out = gr.file_sink(gr.sizeof_gr_complex, "./rx.out")
interp_rate = 128 # tx_samprate = 1M
# dec_rate = 8 # rx_samprate = 8M
dec_rate = 16 #16 # rx_samprate = 4M
sw_dec = 4 #2
# num_taps = int(64000 / ( (dec_rate * 4) * 40 )) #Filter matched to 1/4 of the 40 kHz tag cycle
num_taps = int(64000 / ( (dec_rate * 4) * 256 )) #Filter matched to 1/4 of the 256 kHz tag cycle
taps = [complex(1,1)] * num_taps
matched_filt = gr.fir_filter_ccc(sw_dec, taps);
to_mag = gr.complex_to_mag()
center = rfid.center_ff(4)
mm = rfid.clock_recovery_zc_ff(4,1);
self.reader = rfid.reader_f(int(128e6/interp_rate));
tag_decoder = rfid.tag_decoder_f()
command_gate = rfid.command_gate_cc(12, 60, 64000000 / dec_rate / sw_dec)
to_complex = gr.float_to_complex()
amp = gr.multiply_const_ff(amplitude)
##################################################
# Blocks
##################################################
freq = 915e6 #915e6
rx_gain = 24 #xjtu
tx = uhd.usrp_sink(
device_addr="",
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1,
)
tx.set_samp_rate(128e6/interp_rate)
p = tx.get_gain_range()
tx.set_gain(float(p.start() + p.stop()) / 4)
#r = tx.set_center_freq(freq, 0)
t = tx.set_samp_rate(64e6/dec_rate)
tune_req_tx = uhd.tune_request_t(freq,128e6/interp_rate/2)
tt = tx.set_center_freq(tune_req_tx)
rx = uhd.usrp_source(
options.args,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1,
)
r = rx.set_samp_rate(64e6/dec_rate)
tune_req = uhd.tune_request_t(freq,64e6/dec_rate)
x = rx.set_center_freq(tune_req)
if not x:
print "Couldn't set rx freq"
#g = rx.get_gain_range()
rx.set_gain(rx_gain)
print "***************Info******************"
print "-----tx: get sample rate:"
print (tx.get_samp_rate())
print "tx: get freq:"
print (tx.get_center_freq())
print "-----rx.detail"
print rx.detail()
print "rx: get samp rate"
print (rx.get_samp_rate())
print "rx: get freq "
print (rx.get_center_freq())
print "rx: get gain "
print (rx.get_gain())
print "***************END******************"
command_gate.set_ctrl_out(self.reader.ctrl_q())
tag_decoder.set_ctrl_out(self.reader.ctrl_q())
#########Build Graph
self.connect(rx, matched_filt)
self.connect(matched_filt, command_gate)
self.connect(command_gate, to_mag)
#self.connect(command_gate, agc)
#self.connect(agc, to_mag)
self.connect(to_mag, center, mm, tag_decoder)
#self.connect(to_mag, center, matched_filt_tag_decode, tag_decoder)
self.connect(tag_decoder, self.reader)
self.connect(self.reader, amp)
self.connect(amp, to_complex)
self.connect(to_complex, tx)
#################
#self.connect(command_gate, commandGate_out)
self.connect(rx, rx_out)
channels=list(range(0, 2)),
),
)
#streamer restart/align
stop_cmd = uhd.stream_cmd_t(uhd.stream_cmd_t.STREAM_MODE_STOP_CONTINUOUS)
stop_cmd.stream_now = True
self.uhd_usrp_source_0.issue_stream_cmd(stop_cmd)
stream_cmd = uhd.stream_cmd_t(uhd.stream_cmd_t.STREAM_MODE_START_CONTINUOUS)
stream_cmd.stream_now = False
#delay by 5s
stream_cmd.time_spec = self.uhd_usrp_source_0.get_time_now() + uhd.time_spec_t(
5.0)
self.uhd_usrp_source_0.issue_stream_cmd(stream_cmd)
#freq align - potential phase sync
retune_time = self.uhd_usrp_source_0.get_time_now() + uhd.time_spec_t(5.0)
self.uhd_usrp_source_0.set_command_time(retune_time)
center_freq_tmp = 2.4501e9
tune_req = uhd.tune_request_t(center_freq_tmp)
self.uhd_usrp_source_0.set_center_freq(tune_req, 0)
self.uhd_usrp_source_0.set_center_freq(tune_req, 1)
self.uhd_usrp_source_0.clear_command_time()
print("Finished!")
# %%
def getUhdUSRPSink(fc, lo_off, inter, gain, addr, sync):
"""
Tx
def getUhdUSRPSink(fc, inter, gain, addr, sync)
in:
- fc = center frequency
- lo_off = LO off
- inter = interpolation factor
- gain = gain in the tx, only with 2450
- addr = ip address, format = "addr=ip, mimo_mode="
- sync = if True them sync with external clock
out:
(usrp2, baseband_freq, dxc_freq)
- usrp2 sink object
- baseband_freq
- dxc_freq
"""
rf_sink = uhd.usrp_sink(addr, uhd.io_type_t.COMPLEX_FLOAT32, 1)
# gain
gRange = rf_sink.get_gain_range()
if gRange.start() <> gRange.stop():
rf_sink.set_gain(gain)
print("i: set_gain = " + str(rf_sink.set_gain()))
else:
print("i: this daughterboard not support the set gain behavior")
# samo freq
rf_sink.set_samp_rate(rf_sink.get_clock_rate()/inter)
print("i: samp_freq = " + str(rf_sink.get_samp_rate()))
# center freq
freqRange = rf_sink.get_freq_range()
if float(freqRange.start()) > fc and float(freqRange.stop()) < fc:
fc = float(freqRange.start()+freqRange.stop())/2
print("e: fc have to be between [" + str(freqRange.start()) + ", " + str(freqRange.stop()) + "]")
tune_request = uhd.tune_request_t(fc, lo_off)
tune_res = rf_sink.set_center_freq(tune_request)
# tune_res = rf_sink.set_center_freq(fc)
rf_freq = tune_res.actual_rf_freq
dxc_freq = 0
print("i: actual_rf_freq = " + str(rf_freq) +
"\ni: actual_dsp_freq = " + str(tune_res.actual_dsp_freq) +
"\ni: target_rf_freq = " + str(tune_res.target_rf_freq) +
"\ni: target_dsp_freq = " + str(tune_res.target_dsp_freq))
# sync
if type(sync) == type(False) and bool(sync):
# print "i: sync to pps = " + str(rf_sink.set_time_unknown_pps(uhd.time_spec_t()))
# print "i: sync to pps = " + str(rf_sink.set_time_next_pps(uhd.time_spec_t()))
# Common references signals
ccfg = uhd.clock_config_t()
ccfg.ref_source = uhd.clock_config_t.REF_SMA
ccfg.pps_source = uhd.clock_config_t.PPS_SMA
ccfg.pps_polarity = uhd.clock_config_t.PPS_NEG
rf_sink.set_clock_config(ccfg)
#EO CRS
# sync the device time
# last_pps_time = rf_sink.get_time_last_pps()
# while (last_pps_time != rf_sink.get_time_last_pps()):
# time.sleep(0.1)
rf_sink.set_time_next_pps(uhd.time_spec_t(0.0))
print("i: sync == True")
else:
print("i: sync == False")
# time.sleep(2)
return (rf_sink, rf_freq, dxc_freq)
def getUhdUSRP2Source(fc, lo_off, dec, gain, addr, sync):
"""
Rx
def getUhdUSRP2Source(fc, dec, gain, addr, sync):
in:
- fc = center frequency
- dec = decimation factor
- gain = gain in the tx, only with 2450
- addr = ip address, format = "addr=ip, mimo_mode="
- sync = if True them sync with external clock
out:
(usrp2, baseband_freq, dxc_freq)
- usrp2 source object
- baseband_freq
- dxc_freq
"""
rf_src = uhd.usrp_source(addr, uhd.io_type_t.COMPLEX_FLOAT32, 1)
# gain
gRange = rf_src.get_gain_range()
if gRange.start() <> gRange.stop():
rf_src.set_gain(gain)
print("i: set_gain = " + str(rf_src.get_gain()))
else:
print("i: this daughterboard not support the set gain behavior")
# samo freq
rf_src.set_samp_rate(rf_src.get_clock_rate()/dec)
print("i: samp_freq = " + str(rf_src.get_samp_rate()))
# center freq
freqRange = rf_src.get_freq_range()
if float(freqRange.start()) > fc and float(freqRange.stop()) < fc:
fc = float(freqRange.start()+freqRange.stop())/2
print("e: fc have to be between [" + str(freqRange.start()) + ", " + str(freqRange.stop()) + "]")
tune_request = uhd.tune_request_t(fc, lo_off)
tune_res = rf_src.set_center_freq(tune_request)
rf_freq = tune_res.actual_rf_freq
dxc_freq = 0
print("i: actual_rf_freq = " + str(rf_freq) +
"\ni: actual_dsp_freq = " + str(tune_res.actual_dsp_freq) +
"\ni: target_rf_freq = " + str(tune_res.target_rf_freq) +
"\ni: target_dsp_freq = " + str(tune_res.target_dsp_freq))
# sync
if type(sync) == type(False) and bool(sync):
## print "i: sync to pps = " + str(rf_src.set_time_unknown_pps(uhd.time_spec_t()))
## print "i: sync to pps = " + str(rf_src.set_time_next_pps(uhd.time_spec_t()))
# print "i: sync to pps = " + str(rf_src.set)
# rf_src.set_time_next_pps(uhd.time_spec_t(uhd.time_spec_t.get_system_time().get_real_secs()+1))
# Common references signals
ccfg = uhd.clock_config_t()
ccfg.ref_source = uhd.clock_config_t.REF_SMA
ccfg.pps_source = uhd.clock_config_t.PPS_SMA
ccfg.pps_polarity = uhd.clock_config_t.PPS_NEG
rf_src.set_clock_config(ccfg)
#EO CRS
# sync the device time
# last_pps_time = rf_src.get_time_last_pps()
# while (last_pps_time != rf_src.get_time_last_pps()):
# time.sleep(0.1)
# rf_src.set_time_unknown_pps(uhd.time_spec_t(0.0))
rf_src.set_time_next_pps(uhd.time_spec_t(0.0))
print("i: sync == True")
# EO SDT
else:
print("i: sync == False")
# time.sleep(1)
return (rf_src, rf_freq, dxc_freq)
#def getUSRP2Sink(fc, inter, gain, eth, sync):
# """
# Tx
# def getUSRP2Sink(fc, inter, gain, eth, sync):
#
# in:
# - fc = center frequency
# - inter = interpolation factor
# - gain = gain in the tx, only with 2450
# - eth = ethernet interface name(String)
# - sync = if True them sync with external clock
#
# out:
# (usrp2, baseband_freq, dxc_freq)
# - usrp2 sink object
# - baseband_freq
# - dxc_freq
# """
# rf_sink = usrp2.sink_32fc(eth)
#
# if rf_sink.gain_max() <> rf_sink.gain_min():
# print("i: set_gain = " + str(rf_sink.set_gain(gain)))
# else:
# print("i: this daughterboard not support the set gain behavior")
#
# print("i: set inter = " +str(rf_sink.set_interp(inter)))
# tune_res = rf_sink.set_center_freq(fc)
#
# baseband_freq = tune_res.baseband_freq
# dxc_freq = tune_res.dxc_freq
# print("i: set center freq = " + str(baseband_freq) +
# "\ni: residual freq = " + str(tune_res.residual_freq) +
# "\ni: dxc freq = " + str(dxc_freq))
#
# if type(sync) == type(False) and bool(sync):
## print "i: sync to mimo = " + str(rf_sink.config_mimo(usrp2.MC_WE_LOCK_TO_MIMO))
# print "i: sync to pps = " + str(rf_sink.sync_to_pps())
# print "i: sync to ref clock = " + str(rf_sink.config_mimo(usrp2.MC_WE_LOCK_TO_SMA))
# else:
# print "i: ref clock don't lock = " + str(rf_sink.config_mimo(usrp2.MC_WE_DONT_LOCK))
#
# print("i: samp_freq = " + str(float(rf_sink.dac_rate())/inter))
#
# return (rf_sink, baseband_freq, dxc_freq)
#def getUSRP2Source(fc, dec, gain, eth, sync):
# """
# Rx
# def getUSRP2Source(fc, dec, gain, eth, sync):
#
# in:
# - fc = center frequency
# - dec = decimation factor
# - gain = gain in the tx, only with 2450
# - eth = ethernet interface name(String)
# - sync = if True them sync with external clock
#
# out:
# (usrp2, baseband_freq, dxc_freq)
# - usrp2 source object
# - baseband_freq
# - dxc_freq
# """
#
# rf_src = usrp2.source_32fc(eth)
#
# print("i: set_gain = " + str(rf_src.set_gain(gain)))
# print("i: set int = " +str(rf_src.set_decim(dec)))
# tune_res = rf_src.set_center_freq(fc)
#
# baseband_freq = tune_res.baseband_freq
# dxc_freq = tune_res.dxc_freq
# print("i: set center freq = " + str(baseband_freq) +
# "\ni: residual freq = " + str(tune_res.residual_freq) +
# "\ni: dxc freq = " + str(dxc_freq))
#
# if type(sync) == type(False) and bool(sync):
## print "i: sync to mimo = " + str(rf_src.config_mimo(usrp2.MC_PROVIDE_CLK_TO_MIMO))
# print "i: sync to pps = " + str(rf_src.sync_to_pps())
# print "i: sync to ref clock = " + str(rf_src.config_mimo(usrp2.MC_WE_LOCK_TO_SMA))
# else:
# print "i: ref clock don't lock = " + str(rf_src.config_mimo(usrp2.MC_WE_DONT_LOCK))
#
# print("i: samp_freq = " + str(float(rf_src.adc_rate())/dec))
#
# return (rf_src, baseband_freq, dxc_freq)
average=False,
avg_alpha=None,
title="Frequency Waterfall",
size=(400, 400),
)
self.Add(self.wxgui_waterfallsink2_0_0.win)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(
uhd.tune_request_t(161900000, 19000000), 0)
self.uhd_usrp_sink_0.set_gain(20 if (func_burst_out > 0) else 0, 0)
self.uhd_usrp_sink_0.set_antenna("TX/RX", 0)
self.source_txtimer_0 = analog.sig_source_i(samp_rate,
analog.GR_SQR_WAVE,
doppler_control_freq1, 1,
0)
self.source_txtimer = analog.sig_source_i(samp_rate,
analog.GR_SQR_WAVE,
doppler_control_freq1 / 4, 1,
0)
def _func_burst_out_0_probe():
while True:
val = self.probe_burst_0.level()
try:
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.uhd_usrp_sink_1.set_samp_rate(self.samp_rate)
self.uhd_usrp_sink_1.set_center_freq(uhd.tune_request_t((self.rfFreqMhz+1)*1e6, 2*self.samp_rate), 0)
self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)
def __init__(self, radioHostname='192.168.0.20', radioType='ndr364'):
gr.top_block.__init__(self, "Freq Msg Strobe Test")
Qt.QWidget.__init__(self)
self.setWindowTitle("Freq Msg Strobe Test")
qtgui.util.check_set_qss()
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", "frq_strobe_test")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.radioHostname = radioHostname
self.radioType = radioType
##################################################
# Variables
##################################################
self.radioObj = radioObj = crd.getRadioObject(radioType, verbose=bool(False), host=radioHostname)
self.wbddcRateSet = wbddcRateSet = dict( [(k,v) for k,v in radioObj.getWbddcRateSet().iteritems() if radioObj.getDdcDataFormat(True).get(k,"iq")!="real"] )
self.configFilePath = configFilePath = os.path.expanduser( os.path.join("~",".%s_demo.cfg"%(radioObj.name.lower(),)) )
self._cfg_wbddcRateIndex_config = ConfigParser.ConfigParser()
self._cfg_wbddcRateIndex_config.read(configFilePath)
try: cfg_wbddcRateIndex = self._cfg_wbddcRateIndex_config.getint('wbddc', 'rate_index')
except: cfg_wbddcRateIndex = sorted(wbddcRateSet.keys())[0]
self.cfg_wbddcRateIndex = cfg_wbddcRateIndex
self._cfg_iirAvgExp_config = ConfigParser.ConfigParser()
self._cfg_iirAvgExp_config.read(configFilePath)
try: cfg_iirAvgExp = self._cfg_iirAvgExp_config.getint('gui', 'iirAvgExp')
except: cfg_iirAvgExp = int(3)
self.cfg_iirAvgExp = cfg_iirAvgExp
self.wbddcRateIndex = wbddcRateIndex = cfg_wbddcRateIndex
self.wbddcBwSet = wbddcBwSet = dict( [(k,v) for k,v in radioObj.getWbddcBwSet().iteritems() if radioObj.getDdcDataFormat(True).get(k,"iq")!="real"] )
self.iirAvgExp = iirAvgExp = cfg_iirAvgExp
self._cfg_tunerIndex_config = ConfigParser.ConfigParser()
self._cfg_tunerIndex_config.read(configFilePath)
try: cfg_tunerIndex = self._cfg_tunerIndex_config.getint('tuner', 'index')
except: cfg_tunerIndex = radioObj.getTunerIndexRange()[0]
self.cfg_tunerIndex = cfg_tunerIndex
self._cfg_tunerAtten_config = ConfigParser.ConfigParser()
self._cfg_tunerAtten_config.read(configFilePath)
try: cfg_tunerAtten = self._cfg_tunerAtten_config.getint('tuner', 'atten')
except: cfg_tunerAtten = int(radioObj.getTunerAttenuationRange()[0])
self.cfg_tunerAtten = cfg_tunerAtten
self._cfg_rfFreqMhz_config = ConfigParser.ConfigParser()
self._cfg_rfFreqMhz_config.read(configFilePath)
try: cfg_rfFreqMhz = self._cfg_rfFreqMhz_config.getint('tuner', 'freq')
except: cfg_rfFreqMhz = int(radioObj.getTunerFrequencyRange()[0]/1e6)
self.cfg_rfFreqMhz = cfg_rfFreqMhz
self._cfg_refLevel_config = ConfigParser.ConfigParser()
self._cfg_refLevel_config.read(configFilePath)
try: cfg_refLevel = self._cfg_refLevel_config.getint('display', 'ref_level')
except: cfg_refLevel = 0
self.cfg_refLevel = cfg_refLevel
self._cfg_dynRange_config = ConfigParser.ConfigParser()
self._cfg_dynRange_config.read(configFilePath)
try: cfg_dynRange = self._cfg_dynRange_config.getint('display', 'dyn_range')
except: cfg_dynRange = 120
self.cfg_dynRange = cfg_dynRange
self.wbSampleRate = wbSampleRate = wbddcRateSet[wbddcRateIndex]
self.wbBw = wbBw = wbddcBwSet[wbddcRateIndex]
self.udpBasePort = udpBasePort = 0xcafe
self.tunerIndex = tunerIndex = cfg_tunerIndex
self.tunerAtten = tunerAtten = cfg_tunerAtten
self.samp_rate = samp_rate = 10e6
self.rfFreqMhz = rfFreqMhz = cfg_rfFreqMhz
self.refLevel = refLevel = cfg_refLevel
self.pauseScan = pauseScan = False
self.iirAlpha = iirAlpha = 2.0**(float(-iirAvgExp))
self.fStep = fStep = 100
self.f2 = f2 = int(radioObj.getTunerFrequencyRange()[1]/1e6)
self.f1 = f1 = 100
self.dynRange = dynRange = cfg_dynRange
self.dwell = dwell = 0.5
##################################################
# Blocks
##################################################
self.wbTabs = Qt.QTabWidget()
self.wbTabs_widget_0 = Qt.QWidget()
self.wbTabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.wbTabs_widget_0)
self.wbTabs_grid_layout_0 = Qt.QGridLayout()
self.wbTabs_layout_0.addLayout(self.wbTabs_grid_layout_0)
self.wbTabs.addTab(self.wbTabs_widget_0, 'Spectrum')
self.top_grid_layout.addWidget(self.wbTabs, 1,0,1,3)
self.controlTabs = Qt.QTabWidget()
self.controlTabs_widget_0 = Qt.QWidget()
self.controlTabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.controlTabs_widget_0)
self.controlTabs_grid_layout_0 = Qt.QGridLayout()
self.controlTabs_layout_0.addLayout(self.controlTabs_grid_layout_0)
self.controlTabs.addTab(self.controlTabs_widget_0, 'control')
self.top_grid_layout.addWidget(self.controlTabs, 0,0,1,1)
self._wbddcRateIndex_options = sorted(wbddcRateSet.keys())
self._wbddcRateIndex_labels = ["%d: %ssps"%(k,num_to_str(wbddcRateSet[k])) for k in sorted(wbddcRateSet.keys())]
self._wbddcRateIndex_tool_bar = Qt.QToolBar(self)
self._wbddcRateIndex_tool_bar.addWidget(Qt.QLabel('WBDDC Sample Rate'+": "))
self._wbddcRateIndex_combo_box = Qt.QComboBox()
self._wbddcRateIndex_tool_bar.addWidget(self._wbddcRateIndex_combo_box)
for label in self._wbddcRateIndex_labels: self._wbddcRateIndex_combo_box.addItem(label)
self._wbddcRateIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(self._wbddcRateIndex_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._wbddcRateIndex_options.index(i)))
self._wbddcRateIndex_callback(self.wbddcRateIndex)
self._wbddcRateIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_wbddcRateIndex(self._wbddcRateIndex_options[i]))
self.controlTabs_grid_layout_0.addWidget(self._wbddcRateIndex_tool_bar, 0,1,1,1)
self._tunerIndex_options = radioObj.getTunerIndexRange()
self._tunerIndex_labels = map(str, self._tunerIndex_options)
self._tunerIndex_tool_bar = Qt.QToolBar(self)
self._tunerIndex_tool_bar.addWidget(Qt.QLabel('Tuner Index'+": "))
self._tunerIndex_combo_box = Qt.QComboBox()
self._tunerIndex_tool_bar.addWidget(self._tunerIndex_combo_box)
for label in self._tunerIndex_labels: self._tunerIndex_combo_box.addItem(label)
self._tunerIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(self._tunerIndex_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._tunerIndex_options.index(i)))
self._tunerIndex_callback(self.tunerIndex)
self._tunerIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_tunerIndex(self._tunerIndex_options[i]))
self.controlTabs_grid_layout_0.addWidget(self._tunerIndex_tool_bar, 0,0,1,1)
self._tunerAtten_range = Range(int(radioObj.getTunerAttenuationRange()[0]), int(radioObj.getTunerAttenuationRange()[1]), int(radioObj.getTunerAttenuationRes()), cfg_tunerAtten, 200)
self._tunerAtten_win = RangeWidget(self._tunerAtten_range, self.set_tunerAtten, 'Tuner Atten (dB)', "counter", int)
self.controlTabs_grid_layout_0.addWidget(self._tunerAtten_win, 0,2,1,1)
self._rfFreqMhz_range = Range(int(radioObj.getTunerFrequencyRange()[0]/1e6), int(radioObj.getTunerFrequencyRange()[1]/1e6), 10, cfg_rfFreqMhz, 200)
self._rfFreqMhz_win = RangeWidget(self._rfFreqMhz_range, self.set_rfFreqMhz, 'Tuner Freq (MHz)', "counter_slider", int)
self.controlTabs_grid_layout_0.addWidget(self._rfFreqMhz_win, 0,3,1,2)
self._refLevel_range = Range(-120, +10, 5, cfg_refLevel, (130/5)+1)
self._refLevel_win = RangeWidget(self._refLevel_range, self.set_refLevel, "Ref.\nLevel\n(dB)", "dial", int)
self.wbTabs_grid_layout_0.addWidget(self._refLevel_win, 0,1,1,1)
self._pauseScan_options = (False, True, )
self._pauseScan_labels = ('Run', 'Pause', )
self._pauseScan_group_box = Qt.QGroupBox('Scan')
self._pauseScan_box = Qt.QHBoxLayout()
class variable_chooser_button_group(Qt.QButtonGroup):
def __init__(self, parent=None):
Qt.QButtonGroup.__init__(self, parent)
@pyqtSlot(int)
def updateButtonChecked(self, button_id):
self.button(button_id).setChecked(True)
self._pauseScan_button_group = variable_chooser_button_group()
self._pauseScan_group_box.setLayout(self._pauseScan_box)
for i, label in enumerate(self._pauseScan_labels):
radio_button = Qt.QRadioButton(label)
self._pauseScan_box.addWidget(radio_button)
self._pauseScan_button_group.addButton(radio_button, i)
self._pauseScan_callback = lambda i: Qt.QMetaObject.invokeMethod(self._pauseScan_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._pauseScan_options.index(i)))
self._pauseScan_callback(self.pauseScan)
self._pauseScan_button_group.buttonClicked[int].connect(
lambda i: self.set_pauseScan(self._pauseScan_options[i]))
self.controlTabs_grid_layout_0.addWidget(self._pauseScan_group_box, 1,0,1,1)
self._fStep_range = Range(1, 1000, 10, 100, 200)
self._fStep_win = RangeWidget(self._fStep_range, self.set_fStep, 'Step (MHz)', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._fStep_win, 1,3,1,1)
self._f2_range = Range(int(radioObj.getTunerFrequencyRange()[0]/1e6), int(radioObj.getTunerFrequencyRange()[1]/1e6), 10, int(radioObj.getTunerFrequencyRange()[1]/1e6), 200)
self._f2_win = RangeWidget(self._f2_range, self.set_f2, 'f2 (MHz)', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._f2_win, 1,2,1,1)
self._f1_range = Range(int(radioObj.getTunerFrequencyRange()[0]/1e6), int(radioObj.getTunerFrequencyRange()[1]/1e6), 10, 100, 200)
self._f1_win = RangeWidget(self._f1_range, self.set_f1, 'f1 (MHz)', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._f1_win, 1,1,1,1)
self._dynRange_range = Range(5, 200, 5, cfg_dynRange, (195/5)+1)
self._dynRange_win = RangeWidget(self._dynRange_range, self.set_dynRange, "Dyn.\nRange\n(dB)", "dial", int)
self.wbTabs_grid_layout_0.addWidget(self._dynRange_win, 1,1,1,1)
self._dwell_range = Range(0.001, 10.0, 0.1, 0.5, 200)
self._dwell_win = RangeWidget(self._dwell_range, self.set_dwell, 'dwell', "counter", float)
self.controlTabs_grid_layout_0.addWidget(self._dwell_win, 1,4,1,1)
self.z_tunerControl = CyberRadio.generic_tuner_control_block(
radioObj,
tunerIndex,
True,
1000,
tunerAtten,
1,
None,
{},
False
)
self.y_ddcControl = CyberRadio.generic_ddc_control_block(
radioObj,
tunerIndex,
True,
True,
wbddcRateIndex,
0,
0,
tunerIndex,
0,
-1,
-1,
'',
udpBasePort,
{},
True
)
self.uhd_usrp_sink_1 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
otw_format='sc8',
channels=range(1),
),
)
self.uhd_usrp_sink_1.set_samp_rate(samp_rate)
self.uhd_usrp_sink_1.set_center_freq(uhd.tune_request_t((rfFreqMhz+1)*1e6, 2*samp_rate), 0)
self.uhd_usrp_sink_1.set_gain(20, 0)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
4096, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
wbSampleRate, #bw
"", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(1.0/32)
self.qtgui_freq_sink_x_0.set_y_axis(refLevel-dynRange, refLevel)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(True)
self.qtgui_freq_sink_x_0.set_fft_average(0.2)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not False:
self.qtgui_freq_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.wbTabs_grid_layout_0.addWidget(self._qtgui_freq_sink_x_0_win, 0,0,3,1)
self._iirAvgExp_range = Range(0, 8, 1, cfg_iirAvgExp, 200)
self._iirAvgExp_win = RangeWidget(self._iirAvgExp_range, self.set_iirAvgExp, 'Avg.', "dial", int)
self.wbTabs_grid_layout_0.addWidget(self._iirAvgExp_win, 2,1,1,1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, radioObj.getVitaPayloadSize()/4)
self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc((0.7, ))
self.blocks_message_debug_1 = blocks.message_debug()
self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, 0.1, 1, 0)
self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc(1)
self.CyberRadio_zero_copy_source_0 = CyberRadio.zero_copy_source(
'255.255.255.255', udpBasePort,
1, radioObj.getVitaHeaderSize(), radioObj.getVitaPayloadSize()/4,
radioObj.isByteswapped(), radioObj.isIqSwapped(),
"ip proto 17 and ip dst 255.255.255.255 and udp dst port %d"%(udpBasePort,), True,
)
self.CyberRadio_generic_group_control_block_0 = CyberRadio.generic_group_control_block(
radioObj,
0,
False,
True,
([0,1,2,3,]),
{},
False,
)
self.CyberRadio_freq_msg_strobe_0 = CyberRadio.freq_msg_strobe(
pause = bool(pauseScan),
f1 = f1,
f2 = f2,
step = fStep,
dwell = dwell,
wrap = True,
fManual = rfFreqMhz,
msgUnits = 1.0,
msgRes = 1.0e6,
debug = False,
)
##################################################
# Connections
##################################################
self.msg_connect((self.CyberRadio_freq_msg_strobe_0, 'freq'), (self.uhd_usrp_sink_1, 'command'))
self.msg_connect((self.CyberRadio_freq_msg_strobe_0, 'freq'), (self.z_tunerControl, 'freq'))
self.msg_connect((self.y_ddcControl, 'status'), (self.blocks_message_debug_1, 'print'))
self.msg_connect((self.z_tunerControl, 'freq'), (self.qtgui_freq_sink_x_0, 'freq'))
self.connect((self.CyberRadio_zero_copy_source_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.analog_frequency_modulator_fc_0, 0), (self.blocks_multiply_const_vxx_1, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.analog_frequency_modulator_fc_0, 0))
self.connect((self.blocks_multiply_const_vxx_1, 0), (self.uhd_usrp_sink_1, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.qtgui_freq_sink_x_0, 0))
