def _create_dac_gain_helper(self, vbox, i_or_q):
d = {"1/1": 0xC0, "1/2": 0x40, "1/11": 0x00}
def doit(kv):
dac_gain = kv['dac_gain']
coarse_s = kv['coarse']
print "dac_gain[%d] = %4d" % (i_or_q, dac_gain)
print "coarse = ", coarse_s
return self._set_dac_fine_gain(i_or_q, dac_gain, d[coarse_s])
myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
vbox.Add(hbox, 0, wx.EXPAND)
myform['coarse'] = form.radiobox_field(
parent=self.panel,
sizer=hbox,
callback=myform.check_input_and_call(doit),
choices=['1/11', '1/2', '1/1'],
weight=1,
value='1/1')
myform['dac_gain'] = form.slider_field(
parent=self.panel,
sizer=hbox,
callback=myform.check_input_and_call(doit),
min=-32,
max=31,
value=0,
weight=4)
def _create_dac_offset_helper(self, vbox, i_or_q):
def doit(kv):
drive_positive = kv['drive_positive']
dac_offset = kv['dac_offset']
print "drive_positive =", drive_positive
print "dac_offset[%d] = %4d" % (i_or_q, dac_offset)
# FIXME signed magnitude??
# dac_offset = signed_mag10(dac_offset)
return self._set_dac_offset(i_or_q, dac_offset, int(drive_positive))
def signed_mag10(x):
# not clear from doc if this is really 2's comp or 10-bit signed magnitude
# we'll guess it's 10-bit signed mag
if x < 0:
return (1 << 9) | min(511, max(0, abs(x)))
else:
return (0 << 9) | min(511, max(0, abs(x)))
myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
vbox.Add(hbox, 0, wx.EXPAND)
myform['drive_positive'] = form.checkbox_field(parent=self.panel, sizer=hbox,
callback=myform.check_input_and_call(doit),
weight=0,
label="drive +ve")
myform['dac_offset'] = form.slider_field(parent=self.panel, sizer=hbox,
callback=myform.check_input_and_call(doit),
min=-512, max=511, value=0,
weight=5)
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
vbox.Add(self.scope.win, 1, wx.EXPAND) # Proportion used to be 10
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL) # Create row sizer
hbox.Add((5,0), 0, 0)
myform['freq'] = form.float_field(
parent=self.panel, sizer=hbox, label="Center freq", weight=1,
callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))
myform['antenna'] = form.radiobox_field(parent=self.panel, sizer=hbox, label="Antenna",
value=None, callback=self.set_antenna_callback,
choices=["TX/RX", "RX2", "RXA", "RXB", "RXAB"],major_dimension=5, weight=3)
hbox.Add((5,0), 0, 0)
g = self.subdev.gain_range()
myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
weight=6, # 3
min=int(g[0]), max=int(g[1]),
callback=self.set_gain)
hbox.Add((5,0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
def _form_set_freq2(kv):
return self.set_freq2(kv['freq2'])
vbox.Add(self.scope2.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5, 0), 0, 0)
myform['gain'] = form.slider_field(parent=self.panel,
sizer=hbox,
label="Gain",
weight=3,
min=1,
max=150,
callback=self.set_gain)
hbox.Add((5, 0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv["freq"])
vbox.Add(self.scope1.win, 10, wx.EXPAND)
vbox.Add(self.scope2.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5, 0), 0, 0)
myform["freq"] = form.float_field(
parent=self.panel,
sizer=hbox,
label="Center freq",
weight=1,
callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg),
)
hbox.Add((5, 0), 0, 0)
g = self.subdev.gain_range()
myform["gain"] = form.slider_field(
parent=self.panel, sizer=hbox, label="Gain", weight=3, min=int(g[0]), max=int(g[1]), callback=self.set_gain
)
hbox.Add((5, 0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
vbox.Add(self.scope.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0, 0)
myform['freq'] = form.float_field(
parent=self.panel, sizer=hbox, label="Center freq", weight=1,
callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))
hbox.Add((5,0), 0, 0)
g = self.u.get_gain_range()
# some configurations don't have gain control
if g.stop() > g.start():
myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
weight=3,
min=int(g.start()), max=int(g.stop()),
callback=self.set_gain)
hbox.Add((5,0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _build_subpanel4(self, vbox_arg):
panel = self.panel
vbox = vbox_arg
myform = self.myform
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0, 0)#Add space between the previous and next box, horizontally
# Create a bar or slider horizontally, it is labeled "LO frequency" and it moves in the interval [20M,30M] Hz,once it is moved it calls back to the function set_lo_freq
myform['lofreq'] = form.slider_field(parent=self.panel,
sizer=hbox, label="LO frequency (Hz)",
weight=3,
min=20000000, max=30000000,
callback=self.set_lo_freq)
hbox.Add((10,0), 0)
#Create a checkbox to produce LO signal (the signal will go out when the box is ticked)
myform['LO'] = form.checkbox_field(parent=panel, label="LO generator", sizer=hbox, callback=self.begin_thread2)
vbox.AddSpacer(5)
vbox.Add(hbox, 0, wx.EXPAND)
vbox.AddSpacer(5)
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
vbox.Add(self.scope.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5, 0), 0, 0)
myform['freq'] = form.float_field(parent=self.panel,
sizer=hbox,
label="Center freq",
weight=1,
callback=myform.check_input_and_call(
_form_set_freq,
self._set_status_msg))
hbox.Add((5, 0), 0, 0)
g = self.subdev.gain_range()
myform['gain'] = form.slider_field(parent=self.panel,
sizer=hbox,
label="Gain",
weight=3,
min=int(g[0]),
max=int(g[1]),
callback=self.set_gain)
hbox.Add((5, 0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _build_gui(self, vbox):
if self.scopes.count("I"):
vbox.Add(self.input_fft_scope.win, 5, wx.EXPAND)
if self.scopes.count("F"):
vbox.Add(self.filter_fft_scope.win, 5, wx.EXPAND)
if self.scopes.count("d"):
vbox.Add(self.demod_scope.win, 5, wx.EXPAND)
if self.scopes.count("c"):
vbox.Add(self.clocked_scope.win, 5, wx.EXPAND)
if self.scopes.count("b"):
vbox.Add(self.burst_scope.win, 5, wx.EXPAND)
# add control area at the bottom
if self.using_usrp:
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
self.usrpform = usrpform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0, 0)
g = self.subdev.gain_range()
usrpform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
weight=3,
min=int(g[0]), max=int(g[1]),
callback=self.set_gain)
hbox.Add((5,0), 0, 0)
usrpform['chan'] = form.slider_field( parent=self.panel, sizer=hbox, label="Channel",
weight=3,
min=0, max=1023,
value=self.channel,
callback=self.set_channel)
vbox.Add(hbox, 0, wx.EXPAND)
def _build_gui(self, vbox):
vbox.Add(self.scope.win, 10, wx.EXPAND)
vbox.Add(self.scope2.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0, 0)
g = [0,1000] # Faux gain range
myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
weight=3,
min=int(g[0]), max=int(g[1]),
callback=self.gui_set_gain)
self.myform['gain'].set_value(int(self.options.gain * 10.0))
def _build_gui(self, vbox):
vbox.Add(self.scope.win, 10, wx.EXPAND)
vbox.Add(self.scope2.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5, 0), 0, 0)
g = [0, 1000] # Faux gain range
myform['gain'] = form.slider_field(parent=self.panel,
sizer=hbox,
label="Gain",
weight=3,
min=int(g[0]),
max=int(g[1]),
callback=self.gui_set_gain)
self.myform['gain'].set_value(int(self.options.gain * 10.0))
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
def _form_set_freq2(kv):
return self.set_freq2(kv['freq2'])
vbox.Add(self.scope2.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0, 0)
myform['gain'] = form.slider_field(parent=self.panel, sizer=hbox, label="Gain",
weight=3,
min=1, max=150,
callback=self.set_gain)
hbox.Add((5,0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _create_dac_offset_helper(self, vbox, i_or_q):
def doit(kv):
drive_positive = kv['drive_positive']
dac_offset = kv['dac_offset']
print "drive_positive =", drive_positive
print "dac_offset[%d] = %4d" % (i_or_q, dac_offset)
# FIXME signed magnitude??
# dac_offset = signed_mag10(dac_offset)
return self._set_dac_offset(i_or_q, dac_offset,
int(drive_positive))
def signed_mag10(x):
# not clear from doc if this is really 2's comp or 10-bit signed magnitude
# we'll guess it's 10-bit signed mag
if x < 0:
return (1 << 9) | min(511, max(0, abs(x)))
else:
return (0 << 9) | min(511, max(0, abs(x)))
myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
vbox.Add(hbox, 0, wx.EXPAND)
myform['drive_positive'] = form.checkbox_field(
parent=self.panel,
sizer=hbox,
callback=myform.check_input_and_call(doit),
weight=0,
label="drive +ve")
myform['dac_offset'] = form.slider_field(
parent=self.panel,
sizer=hbox,
callback=myform.check_input_and_call(doit),
min=-512,
max=511,
value=0,
weight=5)
def _create_dac_gain_helper(self, vbox, i_or_q):
d = { "1/1" : 0xC0,
"1/2" : 0x40,
"1/11" : 0x00 }
def doit(kv):
dac_gain = kv['dac_gain']
coarse_s = kv['coarse']
print "dac_gain[%d] = %4d" % (i_or_q, dac_gain)
print "coarse = ", coarse_s
return self._set_dac_fine_gain(i_or_q, dac_gain, d[coarse_s])
myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
vbox.Add(hbox, 0, wx.EXPAND)
myform['coarse'] = form.radiobox_field(parent=self.panel, sizer=hbox,
callback=myform.check_input_and_call(doit),
choices=['1/11', '1/2', '1/1'],
weight=1, value='1/1')
myform['dac_gain'] = form.slider_field(parent=self.panel, sizer=hbox,
callback=myform.check_input_and_call(doit),
min=-32, max=31, value=0,
weight=4)
def make_control(self):
bspace = 10
PyHydra.control.make_control(self)
self.AddLocalMacAddress()
""" Create MCS choicebox_field """
box = wx.BoxSizer(wx.HORIZONTAL)
self.make_label("MCS", box, 35)
self.mcsfield = PyHydra.choicebox_field(self, box, \
value="Auto", callback = self.SetMCS, \
choices = MimoControl.MCS_CHOICES)
self.mcsfield.f.SetToolTipString("Select Modulation and Coding Scheme")
self.AddParam('rate', self.SetMCS)
self.AddParam('mcs', self.SetMCS)
if self.options.rate<0: self.SetParam('mcs', "Auto")
else: self.SetParam('mcs', self.options.rate)
self.cbox.Add (box, 0, wx.ALIGN_LEFT|wx.ALL, border = bspace)
## Create divider
divider = PyHydra.Divider(self)
divider.SetBackgroundColour(wx.Colour(200,200,200) )
self.cbox.AddSpacer((10,10))
self.cbox.Add(divider, 0, wx.EXPAND|wx.GROW)
self.cbox.AddSpacer((10,10))
""" Packet Detector Threshold """
box = wx.BoxSizer(wx.VERTICAL)
self.pd_threshold = form.slider_field(self, box, \
"Packet Detector Threshold (%)", value=self.options.pd_threshold,
callback=self.SetPacketDetectorThreshold, min=20, max=100)
self.AddParam('pd_threshold', self.SetPacketDetectorThreshold)
self.SetParam('pd_threshold', self.options.pd_threshold)
self.cbox.Add(box, 0, wx.ALIGN_LEFT|wx.ALL, border=bspace)
""" Enable Beamforming """
box = wx.BoxSizer(wx.HORIZONTAL)
self.make_label("Enable Beamforming: ", box, 20)
self.enable_beamforming = form.radiobox_field(self, box, label="", \
value = MimoControl.ENABLE_CHOICES[self.options.enable_beamforming], \
callback=self.SetEnableBeamforming, \
choices = MimoControl.ENABLE_CHOICES, major_dimension=0)
#box.Hide(1, recursive=True), box.Remove(1) # Remove default form label
self.enable_beamforming.f.SetLabel("")
self.AddParam('enable_beamforming', self.SetEnableBeamforming)
self.SetParam('enable_beamforming', self.options.enable_beamforming)
self.cbox.Add(box, 0, wx.ALIGN_LEFT|wx.ALL, border=bspace)
""" MAC Monitor Address """
vbox = wx.BoxSizer(wx.VERTICAL)
self.monitor = MimoControl.BROADCAST_ADDR
f = form.static_text_field(self, vbox, value="Monitoring MAC Address: ")
vbox.AddSpacer((10,10) )
box = wx.BoxSizer(wx.HORIZONTAL)
self.fmonitor = form.text_field(self, box, \
value="FF:"*(mimo.mac_monitor.MAC_ADDR_SIZE-1)+"FF", \
callback=self.SetMonitor, weight=1)
self.AddParam('mac_monitor', self.SetMonitor)
box.AddSpacer((10,10) )
self.enable_monitor = form.checkbox_field(self, box, "monitor?", \
value=False, callback=self.SetEnableMonitor, \
weight=0)
box.AddSpacer((100,10) )
vbox.Add(box, 0, wx.EXPAND)
self.cbox.Add(vbox, 1, wx.EXPAND|wx.ALIGN_LEFT|wx.ALL, border=bspace)
self.Fit()
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
vbox.Add(self.scope.win, 10, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((5,0), 0, 0)
myform['freq'] = form.float_field(
parent=self.panel, sizer=hbox, label="Center freq", weight=1,
callback=myform.check_input_and_call(_form_set_freq,
self._set_status_msg))
hbox.Add((5,0), 0, 0)
g = self.u.get_gain_range()
# some configurations don't have gain control
if g.stop() <= g.start():
glow = 0.0
ghigh = 1.0
else:
glow = g.start()
ghigh = g.stop()
myform['gain'] = form.slider_field(parent=self.panel,
sizer=hbox, label="Gain",
weight=3,
min=int(glow), max=int(ghigh),
callback=self.set_gain)
try:
mboard_id = self.u.get_usrp_info().get("mboard_id").split(" ")[0]
mboard_serial = self.u.get_usrp_info().get("mboard_serial")
if mboard_serial == "":
mboard_serial = "no serial"
dboard_id = self.u.get_usrp_info().get("rx_id").split(" ")[0].split(",")[0]
dboard_serial = self.u.get_usrp_info().get("rx_serial")
if dboard_serial == "":
dboard_serial = "no serial"
subdev = self.u.get_subdev_spec()
antenna = self.u.get_antenna()
usrp_config_val = "%s (%s), %s (%s, %s, %s)" % (mboard_id, mboard_serial, dboard_id, dboard_serial, subdev, antenna)
except:
usrp_config_val = "Not implemented in this version."
uhd_box = forms.static_box_sizer(parent=self.panel,
label="UHD (%s)" % (uhd.get_version_string()),
orient=wx.HORIZONTAL)
usrp_config_form = forms.static_text(
parent=self.panel,
sizer=uhd_box,
value=usrp_config_val,
label="USRP",
converter=forms.str_converter(),
)
vbox.Add(uhd_box, 0, wx.EXPAND)
vbox.AddSpacer(5)
hbox.Add((5,0), 0, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
def _generate_panel(self):
# Rx LNA Selection
self.rx_lna_chooser = forms.drop_down(
parent=self.GetWin(),
value=umtrx_lms.lms_get_rx_lna(self.lms),
callback=self.set_rx_lna,
label="Rx LNA",
choices=[0, 1, 2, 3],
labels=["Disabled","LNA1","LNA2", "LNA3"],
# style=wx.RA_HORIZONTAL,
)
self.GridAdd(self.rx_lna_chooser, 0, 0, 1, 1)
# Rx LNA Mode
self.rx_lna_gain_mode_chooser = forms.drop_down(
parent=self.GetWin(),
value=umtrx_lms.lms_get_rx_lna_gain(self.lms),
callback=self.set_rx_lna_gain_mode,
label="Rx LNA Mode",
choices=[3, 2, 1],
labels=["3: Norm","3: -6dB","1: Bypass"],
# style=wx.RA_HORIZONTAL,
)
self.GridAdd(self.rx_lna_gain_mode_chooser, 0, 1, 1, 1)
# Rx LPF bandwidth
self.rx_lna_gain_mode_chooser = forms.drop_down(
parent=self.GetWin(),
value=umtrx_lms.lms_get_rx_lpf_raw(self.lms),
callback=self.set_rx_lpf,
label="Rx LNA LPF",
choices=[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
labels=[0.75, 0.875, 1.25, 1.375, 1.5, 1.92, 2.5, 2.75, 3, 3.5, 4.375, 5, 6, 7, 10, 14],
# style=wx.RA_HORIZONTAL,
)
self.GridAdd(self.rx_lna_gain_mode_chooser, 0, 2, 1, 1)
# Rx VGA1 gain
self.rx_vga1gain = umtrx_lms.lms_get_rx_vga1gain_int(self.lms)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.rx_vga1gain_slider = form.slider_field(
parent=self.GetWin(), sizer=hbox,
value=self.rx_vga1gain,
callback=self.set_rx_vga1gain,
label="Rx VGA1 gain (raw)\n120=30dB, 102=19dB, 2=5dB",
min=0, max=127,
)
self.GridAdd(hbox, 1, 0, 1, 4)
# Rx VGA2 gain
self.rx_vga2gain = umtrx_lms.lms_get_rx_vga2gain(self.lms)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.rx_vga2gain_slider = form.slider_field(
parent=self.GetWin(), sizer=hbox,
value=self.rx_vga2gain,
callback=self.set_rx_vga2gain,
label="\nRx VGA2 gain (dB)",
min=0, max=30,# Not recommended to use above 30
)
self.GridAdd(hbox, 1, 4, 1, 4)
# Tx VGA1 DC I offset
self.tx_vga1dc_i_int = umtrx_lms.lms_get_vga1dc_i_int(self.lms)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.tx_vga1dc_i_int_slider = form.slider_field(
parent=self.GetWin(), sizer=hbox,
value=self.tx_vga1dc_i_int,
callback=self.set_tx_vga1dc_i_int,
label="\nTx VGA1 DC I offset (raw)",
min=0, max=255,
)
self.GridAdd(hbox, 3, 0, 1, 4)
# Tx VGA1 DC Q offset
self.tx_vga1dc_q_int = umtrx_lms.lms_get_vga1dc_q_int(self.lms)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.tx_vga1dc_q_int_slider = form.slider_field(
parent=self.GetWin(), sizer=hbox,
value=self.tx_vga1dc_q_int,
callback=self.set_tx_vga1dc_q_int,
label="\nTx VGA1 DC Q offset (raw)",
min=0, max=255,
)
self.GridAdd(hbox, 3, 4, 1, 4)
# Tx VGA1 gain
self.tx_vga1gain = umtrx_lms.lms_get_tx_vga1gain(self.lms)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.tx_vga1gain_slider = form.slider_field(
parent=self.GetWin(), sizer=hbox,
value=self.tx_vga1gain,
callback=self.set_tx_vga1gain,
label="\nTx VGA1 gain (dB)",
min=-35, max=-4,
)
self.GridAdd(hbox, 4, 0, 1, 4)
# Tx VGA2 gain
self.tx_vga2gain = umtrx_lms.lms_get_tx_vga2gain(self.lms)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.tx_vga2gain_slider = form.slider_field(
parent=self.GetWin(), sizer=hbox,
value=self.tx_vga2gain,
callback=self.set_tx_vga2gain,
label="\nTx VGA2 gain (dB)",
min=0, max=25,
)
self.GridAdd(hbox, 4, 4, 1, 4)
def __init__(self, frame, panel, vbox, argv, panel_info):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
signal_type = default_signal_type # not yet an option
# command line options
parser = OptionParser(option_class=eng_option)
parser.add_option("-r", "--sample-rate",type="eng_float",
default=default_rate,
help="set flow graph sample rate [default=%s]" % default_rate)
parser.add_option ("-f", "--freq", type="eng_float",
default=default_freq,
help="set signal frequency [default=%s]" % default_freq)
parser.add_option ("-a", "--amplitude", type="eng_float",
default=default_ampl,
help="set signal amplitude [default %s]" % default_ampl)
parser.add_option ("--gaussian", dest="noise_type",
action="store_const", const=gr.GR_GAUSSIAN,
help="generate Gaussian noise (-x is variance)",
default=default_noise_type)
parser.add_option ("--uniform", dest="noise_type",
action="store_const", const=gr.GR_UNIFORM,
help="generate Uniform noise (-x is peak-to-peak)")
parser.add_option ("-x", "--noise_amplitude", type="eng_float",
default=default_noise_ampl,
help="set noise amplitude (variance or p-p) [default %s]" % default_noise_ampl)
parser.add_option("-n", "--frame_decim", type="int",
default=default_frame_decim,
help="set oscope frame decimation factor to DECIM [default=%s]" % default_frame_decim)
parser.add_option("-v", "--v_scale", type="eng_float",
default=default_v_scale,
help="set oscope initial V/div [default=%s]" % default_v_scale)
parser.add_option("-t", "--t_scale", type="eng_float",
default=default_t_scale,
help="set oscope initial s/div [default=%s]" % default_t_scale)
parser.add_option("-l", "--ref_level", type="eng_float",
default=default_ref_level,
help="set fft reference level [default=%sdB]" % default_ref_level)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
# flow graph, including scope and fft frames
sample_rate = int(options.sample_rate)
# signal, noise sources need to be attributes so callbacks can get them
self.signal = gr.sig_source_f(sample_rate, gr.GR_SIN_WAVE, options.freq,
options.amplitude, 0.0)
# Seed copied from example at cswiger/noise_source.html
self.noise = gr.noise_source_f(options.noise_type,
options.noise_amplitude,
2482)
add = gr.add_ff()
throttle = gr.throttle(gr.sizeof_float, sample_rate)
(scope_title, scope_panel, scope_vbox) = panel_info[1] #0 is ctrl panel
scope = scopesink2.scope_sink_f(scope_panel,
sample_rate=sample_rate,
frame_decim=options.frame_decim,
v_scale=options.v_scale,
t_scale=options.t_scale)
scope_vbox.Add (scope.win, 1, wx.EXPAND)
fft_size = 256
(fft_title, fft_panel, fft_vbox) = panel_info[2] # 0 is control panel
fft = fftsink2.fft_sink_f (fft_panel,title=fft_title,
fft_size=fft_size*2,
sample_rate=sample_rate, baseband_freq=0,
ref_level=options.ref_level,
y_per_div=10)
fft_vbox.Add (fft.win, 1, wx.EXPAND)
self.connect (self.signal, (add,0))
self.connect (self.noise, (add,1))
self.connect (add, throttle)
# self.connect (throttle, (scope, 0))
# self.connect (throttle, (scope, 1)) # can't leave scope in unconnected
self.connect (throttle, scope)
self.connect (throttle, fft)
# control panel frame
sliders = form.form()
vbox.Add((0,10), 0)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((10,0), 0)
sliders['signal_type'] = form.static_text_field(parent=panel,sizer=hbox)
vbox.Add(hbox, 0, wx.EXPAND)
vbox.Add((0,10), 0)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((10,0), 0)
sliders['signal_freq'] = form.slider_field(parent=panel, sizer=hbox,
label="Frequency",
weight=3,
min=0, max=2*options.freq,
callback=self.set_signal_freq)
vbox.Add(hbox, 0, wx.EXPAND)
vbox.Add((0,10), 0)
hbox = wx.BoxSizer(wx.HORIZONTAL) # apparently you can rebind hbox
hbox.Add((10,0), 0)
sliders['signal_ampl'] = form.slider_field(parent=panel, sizer=hbox,
label="Amplitude",
weight=3,
min=0, max=usrp_full_scale,
callback=self.set_signal_ampl)
vbox.Add(hbox, 0, wx.EXPAND)
vbox.Add((0,20), 0)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((10,0), 0)
sliders['noise_type'] = form.static_text_field(parent=panel,sizer=hbox)
vbox.Add(hbox, 0, wx.EXPAND)
vbox.Add((0,10), 0)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((10,0), 0)
sliders['noise_ampl'] = form.slider_field(parent=panel, sizer=hbox,
label="Amplitude",
weight=3,
min=0, max=usrp_full_scale,
callback=self.set_noise_ampl)
vbox.Add(hbox, 0, wx.EXPAND)
vbox.Add((0,10), 0)
sliders['signal_type'].set_value("Signal: %s"
% signal_string[signal_type])
sliders['noise_type'].set_value("Noise: %s"
% noise_string[options.noise_type])
sliders['signal_freq'].set_value(options.freq)
sliders['signal_ampl'].set_value(options.amplitude)
sliders['noise_ampl'].set_value(options.noise_amplitude)
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
def _form_set_dm(kv):
return self.set_dm(kv['DM'])
def _form_set_doppler(kv):
return self.set_doppler(kv['Doppler'])
# Position the FFT or Waterfall
vbox.Add(self.scope.win, 5, wx.EXPAND)
vbox.Add(self.chart.win, 5, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((7, 0), 0, wx.EXPAND)
vbox1 = wx.BoxSizer(wx.VERTICAL)
myform['freq'] = form.float_field(parent=self.panel,
sizer=vbox1,
label="Center freq",
weight=1,
callback=myform.check_input_and_call(
_form_set_freq,
self._set_status_msg))
vbox1.Add((3, 0), 0, 0)
# To show current Local Mean Sidereal Time
myform['lmst_high'] = form.static_text_field(parent=self.panel,
sizer=vbox1,
label="Current LMST",
weight=1)
vbox1.Add((3, 0), 0, 0)
# To show current spectral cursor data
myform['spec_data'] = form.static_text_field(parent=self.panel,
sizer=vbox1,
label="Pulse Freq",
weight=1)
vbox1.Add((3, 0), 0, 0)
# To show best pulses found in FFT output
myform['best_pulse'] = form.static_text_field(parent=self.panel,
sizer=vbox1,
label="Best freq",
weight=1)
vbox1.Add((3, 0), 0, 0)
vboxBogus = wx.BoxSizer(wx.VERTICAL)
vboxBogus.Add((2, 0), 0, wx.EXPAND)
vbox2 = wx.BoxSizer(wx.VERTICAL)
g = self.subdev.gain_range()
myform['gain'] = form.slider_field(parent=self.panel,
sizer=vbox2,
label="RF Gain",
weight=1,
min=int(g[0]),
max=int(g[1]),
callback=self.set_gain)
vbox2.Add((6, 0), 0, 0)
myform['average'] = form.slider_field(parent=self.panel,
sizer=vbox2,
label="Spectral Averaging",
weight=1,
min=1,
max=200,
callback=self.set_averaging)
vbox2.Add((6, 0), 0, 0)
myform['foldavg'] = form.slider_field(
parent=self.panel,
sizer=vbox2,
label="Folder Averaging",
weight=1,
min=1,
max=20,
callback=self.set_folder_averaging)
vbox2.Add((6, 0), 0, 0)
#myform['volume'] = form.quantized_slider_field(parent=self.panel, sizer=vbox2,
#label="Audio Volume", weight=1, range=(-20, 0, 0.5), callback=self.set_volume)
#vbox2.Add((6,0), 0, 0)
myform['DM'] = form.float_field(
parent=self.panel,
sizer=vbox2,
label="DM",
weight=1,
callback=myform.check_input_and_call(_form_set_dm))
vbox2.Add((6, 0), 0, 0)
myform['Doppler'] = form.float_field(
parent=self.panel,
sizer=vbox2,
label="Doppler",
weight=1,
callback=myform.check_input_and_call(_form_set_doppler))
vbox2.Add((6, 0), 0, 0)
# Baseband recording control
buttonbox = wx.BoxSizer(wx.HORIZONTAL)
self.record_control = form.button_with_callback(
self.panel,
label="Recording baseband: Off ",
callback=self.toggle_recording)
self.record_pulse_control = form.button_with_callback(
self.panel,
label="Recording pulses: Off ",
callback=self.toggle_pulse_recording)
buttonbox.Add(self.record_control, 0, wx.CENTER)
buttonbox.Add(self.record_pulse_control, 0, wx.CENTER)
vbox.Add(buttonbox, 0, wx.CENTER)
hbox.Add(vbox1, 0, 0)
hbox.Add(vboxBogus, 0, 0)
hbox.Add(vbox2, wx.ALIGN_RIGHT, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
self.lmst_timer = wx.PyTimer(self.lmst_timeout)
self.lmst_timeout()
def __init__(self, options):
grc_wxgui.top_block_gui.__init__(self, title="DSSDR")
self.initialized = False
self.stopped = False
self.options = copy.copy(options)
self._constellation = digital.constellation_bpsk()
self._excess_bw = options.excess_bw
self._phase_bw = options.phase_bw
self._freq_bw = options.freq_bw
self._timing_bw = options.timing_bw
self._if_freq = options.if_freq
self._timing_max_dev= 1.5
self._demod_class = digital.bpsk_demod # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
self._samples_per_second = 2e6
self._nav_samples_per_second = 16e6
self._down_decim = 1
self._down_samples_per_second = self._scope_sample_rate = self._samples_per_second/self._down_decim
self._up_samples_per_second = 1e6
self._asm_threshold = 0
self._access_code = None
self._tm_packet_id = 4
self._timestamp_id = 5
self._down_bitrate = options.bitrate
self._up_bitrate = options.up_bitrate
self._up_samples_per_symbol = self._up_samples_per_second/self._up_bitrate
self._samples_per_symbol = self._samples_per_second/self._down_decim/self._down_bitrate
self._down_sub_freq = options.down_sub_freq
self._up_sub_freq = 25e3
self._tm_len = 8920
self._up_tm_len = 8920
self._coding_method = options.coding_method
self._up_coding_method = 'None'
self._up_subcarrier = 'Square'
self._rs_i = 1
self._ccsds_channel = 38
self._uhd_carrier_offset = 10e3
self._turn_div = 749
self._turn_mult = 880
self._modulation_index = 'pi/3'
self._up_modulation_index = 1.047
self._max_carrier_offset = 0.1
self._dssdr_mixer_freq = options.rf_freq
self._up_coding_rate = '1'
self._down_coding_rate = '1'
self._down_conv_en = "False"
self._down_randomizer_en = options.down_randomizer_en
self._down_manchester_en = options.down_manchester_en
self._up_conv_en = "False"
self._up_idle_sequence = "\\x55"
self._down_default_gain = 64
self._up_default_gain = 44
self._up_en = True
if self._access_code is None:
self._access_code = packet_utils.default_access_code
#Construct the lookup table for parameter-setting functions
self.param_setters = {
"DSSDR_CHANNEL": self.setChannel,
"DSSDR_LO_FREQ": self.setLOFreq,
"DSSDR_REF_FREQ": self.setRefFreq,
"DSSDR_TURN_MULT": self.setTurnMult,
"DSSDR_TURN_DIV": self.setTurnDiv,
"DSSDR_UP_GAIN": self.setUpGain,
"DSSDR_DOWN_GAIN": self.setDownGain,
"DSSDR_UP_BITRATE": self.setUpBitrate,
"DSSDR_DOWN_BITRATE": self.setDownBitrate,
"DSSDR_DOWN_SAMPLE_RATE": self.setSampRate,
"DSSDR_UP_SUB_FREQ": self.setUpSubFreq,
"DSSDR_DOWN_SUB_FREQ": self.setDownSubFreq,
"DSSDR_DOPPLER_REPORT": self.dopplerReport,
"DSSDR_PN_RANGE": self.rangePN,
"DSSDR_SEQUENTIAL_RANGE": self.rangeSequential,
"DSSDR_DOWN_CODING_METHOD": self.setDownCodingMethod,
"DSSDR_UP_CODING_METHOD": self.setUpCodingMethod,
"DSSDR_DOWN_TM_LEN": self.setTMLen,
"DSSDR_UP_TM_LEN": self.setUpTMLen,
"DSSDR_DOWN_MOD_IDX": self.setDownModulationIndex,
"DSSDR_UP_MOD_IDX": self.setUpModulationIndex,
"DSSDR_DOWN_CONV_EN": self.setDownConvEn,
"DSSDR_UP_CONV_EN": self.setUpConvEn,
"DSSDR_ASM_TOL": self.setASMThreshold,
"DSSDR_UP_SWEEP": self.freqSweep,
"DSSDR_UP_IDLE": self.setUpIdleSequence,
"DSSDR_UP_EN": self.setUpEn,
"DSSDR_SYNC_TIME": self.syncSDRTime,
"DSSDR_UP_SWEEP": self.freqSweep,
"DSSDR_DOWN_ACQUIRE": self.acquireCarrier,
"DSSDR_INPUT_SELECT": self.setPanelSelect,
"DSSDR_REF_SELECT": self.setRefSelect,
"DSSDR_PPS_SELECT": self.setPPSSelect
}
#TODO:Add status fields for things like DSSDR_REF_LOCK
self._dssdr_channels = {
3: [7149597994, 8400061729],
4: [7150753857, 8401419752],
5: [7151909723, 8402777779],
6: [7153065586, 8404135802],
7: [7154221449, 8405493825],
8: [7155377316, 8406851853],
9: [7156533179, 8408209877],
10: [7157689045, 8409567903],
11: [7158844908, 8410925927],
12: [7160000771, 8412283950],
13: [7161156637, 8413641977],
14: [7162312500, 8415000000],
15: [7163468363, 8416358023],
16: [7164624229, 8417716050],
17: [7165780092, 8419074073],
18: [7166935955, 8420432097],
19: [7168091821, 8421790123],
20: [7169247684, 8423148147],
21: [7170403551, 8424506175],
22: [7171559414, 8425864198],
23: [7172715277, 8427222221],
24: [7173871143, 8428580248],
25: [7175027006, 8429938271],
26: [7176182869, 8431296295],
27: [7177338735, 8432654321],
28: [7178494598, 8434012345],
29: [7179650464, 8435370372],
30: [7180806327, 8436728395],
31: [7181962190, 8438086418],
32: [7183118057, 8439444446],
33: [7184273920, 8440802469],
34: [7185429783, 8442160493],
35: [7186585649, 8443518520],
36: [7187741512, 8444876543],
37: [7188897378, 8446234570],
38: [7190000000, 8450000000],
}
#FLOWGRAPH STUFF
if options.test == True:
self.u = blks2.tcp_source(
itemsize=gr.sizeof_gr_complex*1,
addr="",
port=12905,
server=True
)
elif options.fromfile == True:
self.u2 = blocks.file_meta_source("iq_in.dat")
self.u = blocks.throttle(gr.sizeof_gr_complex*1, self._samples_per_second)
elif options.frombitlog == True:
self.u3 = blocks.file_source(gr.sizeof_char, "bitstream_recording.in", True)
self.u2 = blocks.uchar_to_float()
self.u1 = blocks.throttle(gr.sizeof_float*1, self._down_bitrate)
self.u = blocks.add_const_ff(-0.5)
else:
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
self.u.set_clock_source("external")
self.u.set_time_source("external")
self.u.set_samp_rate(self._samples_per_second)
self.u.set_antenna("RX2")
self.u.set_gain(self._down_default_gain)
self.frontend = dfi.dssdrFrontendInterface(self.u)
if options.debug_pps == True:
self.debug_pps = blocks.tag_debug(gr.sizeof_gr_complex, "debug-pps", "rx_time")
if options.tofile == True:
self.u_tx = blocks.file_meta_sink(gr.sizeof_gr_complex, "iq_out.dat", self._up_samples_per_second)
elif options.tonull == True:
self.u_tx = blocks.null_sink(gr.sizeof_gr_complex)
else:
self.u_tx = uhd.usrp_sink(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
self.u_tx.set_clock_source("external")
self.u_tx.set_time_source("external")
self.u_tx.set_samp_rate(self._up_samples_per_second)
self.u_tx.set_antenna("TX/RX")
self.u_tx.set_gain(self._up_default_gain)
#GUI STUFF
if options.graphics == True:
self.nb0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.nb0.AddPage(grc_wxgui.Panel(self.nb0), "RX")
self.nb0.AddPage(grc_wxgui.Panel(self.nb0), "TX")
self.nb0.AddPage(grc_wxgui.Panel(self.nb0), "Nav")
self.Add(self.nb0)
self.constellation_scope = scopesink2.scope_sink_c(
self.nb0.GetPage(0).GetWin(),
title="Scope Plot",
sample_rate=self._scope_sample_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=True,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb0.GetPage(0).Add(self.constellation_scope.win)
#self.constellation_scope.win.set_marker('plus')
self._scope_is_fft = False
self.time_scope = scopesink2.scope_sink_f(
self.nb0.GetPage(0).GetWin(),
title="Scope Plot",
sample_rate=self._scope_sample_rate,
v_scale=0,
v_offset=0,
t_scale=.005,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb0.GetPage(0).Add(self.time_scope.win)
self.nb0.GetPage(0).GetWin()._box.Hide(self.time_scope.win)
self.fft_scope = fftsink2.fft_sink_c(
self.nb0.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=self._scope_sample_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.nb0.GetPage(0).Add(self.fft_scope.win)
self.nb0.GetPage(0).GetWin()._box.Hide(self.fft_scope.win)
self.row1_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.recording_onoff_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Off',
callback=self.setRecording,
label="IQ Recording",
choices=['Off','On'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.front_panel_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='RF',
callback=self.setPanelSelect,
label="Input Select",
choices=['RF','IF'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.ref_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Internal',
callback=self.setRefSelect,
label="Ref Select",
choices=['Internal','External'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.pps_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Internal',
callback=self.setPPSSelect,
label="PPS Select",
choices=['Internal','External'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.sync_button = forms.button(
parent=self.nb0.GetPage(0).GetWin(),
value='Sync to PPS',
callback=self.syncSDRTime,
choices=['Sync to PPS'],
style=wx.RA_HORIZONTAL,
)
self.ref_locked_text = forms.static_text(
parent=self.nb0.GetPage(0).GetWin(),
value="",
callback=self.setRefLocked,
label="",
converter=forms.str_converter(),
)
self.row1_sizer.Add(self.recording_onoff_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.front_panel_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.ref_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.pps_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.sync_button, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.ref_locked_text, flag=wx.ALIGN_CENTER)
self.nb0.GetPage(0).Add(self.row1_sizer)
self.complex_scope_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Constellation',
callback=self.setComplexScopeStyle,
label="Complex Scope",
choices=['Constellation','FFT'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self.complex_scope_chooser)
self.scope_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='USRP',
callback=self.setScopePoint,
label="Scope Probe Point",
choices=['USRP','Carrier Tracking','Sub-Carrier Costas','Sub-Carrier Sync','Data Sync'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self.scope_chooser)
self._bitrate_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_bitrate,
callback=self.setDownBitrate,
label="Symbol Rate",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._bitrate_text_box)
self._samprate_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._samples_per_second,
callback=self.setSampRate,
label="Sampling Rate",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._samprate_text_box)
self._subcfreq_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_sub_freq,
callback=self.setDownSubFreq,
label="Downlink Subcarrier Frequency",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._subcfreq_text_box)
self._mod_index_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value=self._modulation_index,
callback=self.setDownModulationIndex,
label="Modulation Index",
choices=['pi/2', 'pi/3'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self._mod_index_chooser)
self._pktlen_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._tm_len,
callback=self.setTMLen,
label="Downlink Packet Length (bits)",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._pktlen_text_box)
self._coding_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value=self._coding_method,
callback=self.setDownCodingMethod,
label="Coding",
choices=['None', 'RS', 'Turbo 1/2', 'Turbo 1/3', 'Turbo 1/4', 'Turbo 1/6'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self._coding_chooser)
self._down_conv_check_box = forms.check_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_conv_en,
callback=self.setDownConvEn,
label="Convolutional Decode",
true="True",
false="False",
)
self.nb0.GetPage(0).Add(self._down_conv_check_box)
self._down_randomizer_check_box = forms.check_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_randomizer_en,
callback=self.setDownRandomizerEn,
label="De-randomizer",
true=True,
false=False,
)
self.nb0.GetPage(0).Add(self._down_randomizer_check_box)
self._down_manchester_check_box = forms.check_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_manchester_en,
callback=self.setDownManchesterEn,
label="Manchester Decode",
true=True,
false=False,
)
self.nb0.GetPage(0).Add(self._down_manchester_check_box)
self._pktlen_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._asm_threshold,
callback=self.setASMThreshold,
label="ASM Error Tolerance (bits)",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._pktlen_text_box)
self._coding_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value=self._rs_i,
callback=self.setRSI,
label="Reed-Solomon Interleaving Depth",
choices=[1,5],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self._coding_chooser)
self._ccsds_chan_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._ccsds_channel,
callback=self.setChannel,
label="CCSDS Channel",
converter=forms.int_converter(),
)
self.nb0.GetPage(0).Add(self._ccsds_chan_text_box)
self.setChannel(self._ccsds_channel)
if options.test == True or options.fromfile == True or options.frombitlog == True:
glow = 0.0
ghigh = 1.0
cur_g = 0.5
else:
g = self.u.get_gain_range()
cur_g = self._down_default_gain
# some configurations don't have gain control
if g.stop() <= g.start():
glow = 0.0
ghigh = 1.0
else:
glow = g.start()
ghigh = g.stop()
self._uhd_gain_slider = wx.BoxSizer(wx.HORIZONTAL)
form.slider_field(
parent=self.nb0.GetPage(0).GetWin(),
sizer=self._uhd_gain_slider,
label="USRP RX Gain",
weight=3,
min=int(glow),
max=int(ghigh),
value=cur_g,
callback=self.setDownGain
)
self.nb0.GetPage(0).Add(self._uhd_gain_slider)
#TX chain GUI components
if options.test == True or options.tofile == True or options.tonull == True:
gtxlow = 0.0
gtxhigh = 1.0
cur_gtx = 0.5
else:
gtx = self.u_tx.get_gain_range()
cur_gtx = self._up_default_gain
# some configurations don't have gain control
if gtx.stop() <= gtx.start():
gtxlow = 0.0
gtxhigh = 1.0
else:
gtxlow = gtx.start()
gtxhigh = gtx.stop()
self._up_en_chooser = forms.check_box(
parent=self.nb0.GetPage(1).GetWin(),
value='True',
callback=self.setUpEn,
label="TX Enable",
true='True',
false='False',
)
self.nb0.GetPage(1).Add(self._up_en_chooser)
self._uhd_tx_gain_slider = wx.BoxSizer(wx.HORIZONTAL)
form.slider_field(
parent=self.nb0.GetPage(1).GetWin(),
sizer=self._uhd_tx_gain_slider,
label="USRP TX Gain",
weight=3,
min=int(gtxlow),
max=int(gtxhigh),
value=cur_gtx,
callback=self.setUpGain
)
self.nb0.GetPage(1).Add(self._uhd_tx_gain_slider)
self._subcfreq_up_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_sub_freq,
callback=self.setUpSubFreq,
label="Uplink Subcarrier Frequency",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._subcfreq_up_text_box)
self._up_bitrate_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_bitrate,
callback=self.setUpBitrate,
label="Uplink Bitrate",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._up_bitrate_text_box)
self._up_data_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value="1234ABCD",
callback=self.txData,
label="TX Data",
converter=forms.str_converter(),
)
self.nb0.GetPage(1).Add(self._up_data_text_box)
self._up_mod_index_chooser = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_modulation_index,
callback=self.setUpModulationIndex,
label="Uplink Modulation Index",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._up_mod_index_chooser)
self._up_coding_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_coding_method,
callback=self.setUpCodingMethod,
label="Coding",
choices=['None', 'RS'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(1).Add(self._up_coding_chooser)
self._subcarrier_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_subcarrier,
callback=self.setUpSubcarrier,
label="Subcarrier Type",
choices=['Square','Sine'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(1).Add(self._subcarrier_chooser)
self._up_conv_check_box = forms.check_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_conv_en,
callback=self.setUpConvEn,
label="Convolutional Encode",
true="True",
false="False",
)
self.nb0.GetPage(1).Add(self._up_conv_check_box)
self._up_pktlen_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_tm_len,
callback=self.setUpTMLen,
label="Uplink Packet Length (bits)",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._up_pktlen_text_box)
self._uhd_offset_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._uhd_carrier_offset,
callback=self.setUHDCarrierOffset,
label="USRP Offset Frequency (Hz)",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._uhd_offset_text_box)
self._sweep_gen_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value="rf2_1",
callback=self.freqSweep,
label="Frequency Sweep Profile",
converter=forms.str_converter(),
)
self.nb0.GetPage(1).Add(self._sweep_gen_text_box)
self._idle_sequence_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_idle_sequence,
callback=self.setUpIdleSequence,
label="Uplink Idle Sequence",
converter=forms.str_converter(),
)
self.nb0.GetPage(1).Add(self._idle_sequence_text_box)
self._pn_ranging_text_box = forms.text_box(
parent=self.nb0.GetPage(2).GetWin(),
value="",
callback=self.rangePN,
label="Queue PN Ranging",
converter=forms.str_converter(),
)
self.nb0.GetPage(2).Add(self._pn_ranging_text_box)
self._sequential_ranging_text_box = forms.text_box(
parent=self.nb0.GetPage(2).GetWin(),
value="",
callback=self.rangeSequential,
label="Queue Sequential Ranging",
converter=forms.str_converter(),
)
self.nb0.GetPage(2).Add(self._sequential_ranging_text_box)
self.row2_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.freq_acq_button = forms.button(
parent=self.nb0.GetPage(2).GetWin(),
value='Acquire Carrier Offset',
callback=self.acquireCarrier,
choices=['Acquire Carrier Offset'],
style=wx.RA_HORIZONTAL,
)
self.carrier_offset_text = forms.static_text(
parent=self.nb0.GetPage(2).GetWin(),
value="",
label="",
converter=forms.str_converter(),
)
self.row2_sizer.Add(self.freq_acq_button, flag=wx.ALIGN_CENTER)
self.row2_sizer.Add(self.carrier_offset_text, flag=wx.ALIGN_CENTER)
self.nb0.GetPage(2).Add(self.row2_sizer)
self.file_sink = blocks.file_meta_sink(gr.sizeof_gr_complex, "iq_recording.dat", self._samples_per_second)
self.file_sink.close()
self.iq_recording_ctr = 0
# Selection logic to switch between recording and normal flowgraph routes
# NOTE: u_valve logic is implemented backwards in GNURadio....
#self.u_valve = blks2.valve(
# item_size=gr.sizeof_gr_complex,
# open=False
#)
# Temporary code used to verify coherent turnaround
self.turnaround_mixer = blocks.multiply_cc()
self.turnaround_mixer_source = analog.sig_source_c(self._down_samples_per_second, analog.GR_SIN_WAVE, -25e3, 1.0)
self.turnaround_iir = filter.single_pole_iir_filter_cc(0.0001)
self.turnaround_null = blocks.null_sink(gr.sizeof_float)
# PLL and associated carrier for tracking carrier frequency if residual carrier is used
self.carrier_tracking = sdrp.pll_freq_acq_cc(math.pi/2000, math.pi, -math.pi, int(options.acq_samples))
self.imag_to_float = blocks.complex_to_imag()
#Suppressed carrier requires costas after subcarrier mixer
self.subcarrier_costas = digital.costas_loop_cc(0.001, 2)
self.real_to_float = blocks.complex_to_real()
#Square wave subcarrier sync
self.subcarrier_sync = sdrp.square_sub_tracker_ff(0.001, 2*self._down_sub_freq/self._down_samples_per_second*1.0001, 2*self._down_sub_freq/self._down_samples_per_second*0.9999)
#Data sync
self.data_sync = sdrp.square_data_tracker_ff(0.001, self._down_bitrate/self._down_samples_per_second*1.001, self._down_bitrate/self._down_samples_per_second*0.999)
#Data framing
self.soft_correlator = sdrp.correlate_soft_access_tag_ff(conv_packed_binary_string_to_1_0_string('\x1A\xCF\xFC\x1D'), self._asm_threshold, "asm_corr")
self.conv_decoder = sdrp.ccsds_tm_conv_decoder("asm_corr")
self.de_randomizer = sdrp.ccsds_tm_derandomizer("asm_corr")
self.tm_framer = sdrp.ccsds_tm_framer(self._tm_packet_id, self._timestamp_id, "asm_corr", "rx_time", self._down_bitrate)
self.tm_framer.setFrameLength(self._tm_len)
self._current_scope_block = None
self._current_scoped_block = self.u
self._current_scoped_block_port = 0
self._recording = 'Off'
#TX path in flowgraph
self.pkt_gen_msgq = gr.msg_queue(10)
self.pkt_gen = sdrp.ccsds_tm_tx(self._tm_packet_id, self._timestamp_id, 1.0, 16, self.pkt_gen_msgq)
self.conj = blocks.conjugate_cc()
#Sweep generator for transponder lock
self.sweep_gen = sdrp.sweep_generator_cc(self._up_samples_per_second)
# DSSDR subcarrier mixer (either 25 kHz or 0 kHz depending on baud rate)
self.up_subcarrier_mixer = blocks.multiply_ff()
self.subcarrier_mixer_source_tx = analog.sig_source_f(self._up_samples_per_second, analog.GR_SQR_WAVE, 25e3, 2.0, -1.0)
self.phase_mod_tx = analog.phase_modulator_fc(self._up_modulation_index)
self.tx_attenuator = blocks.multiply_const_cc((0.1+0.0j))
#Add in bit recorder if needed
if self.options.bitlog:
self.bit_slicer = digital.binary_slicer_fb()
self.bit_recorder = blocks.file_sink(1, "bitstream_recording.out")
self.setDownCodingMethod(self._coding_method)
self.setUpCodingMethod("None")
self.setUpSubcarrier(self._up_subcarrier)
self.setDownBitrate(self._down_bitrate)
self.setUpBitrate(self._up_bitrate)
self.setDownModulationIndex(self._modulation_index)
self.setUpModulationIndex(self._up_modulation_index)
self.setDownConvEn(self._down_conv_en)
self.setUpConvEn(self._up_conv_en)
self.setUpIdleSequence(self._up_idle_sequence)
self.setDownRandomizerEn(self._down_randomizer_en)
self.setDownManchesterEn(self._down_manchester_en)
#Connection to outside world
self.socket_pdu = blocks.socket_pdu("TCP_SERVER", "127.0.0.1", "12902", 10000)
self.sdrp_interpreter = sdrp.sdrp_packet_interpreter()
self.msg_connect(self.tm_framer, "tm_frame_out", self.sdrp_interpreter, "sdrp_pdu_in")
self.msg_connect(self.sdrp_interpreter, "socket_pdu_out", self.socket_pdu, "pdus")
self.msg_connect(self.socket_pdu, "pdus", self.sdrp_interpreter, "socket_pdu_in")
self.msg_connect(self.sdrp_interpreter,"sdrp_pdu_out", self.pkt_gen, "ccsds_tx_msg_in")
if options.test == False and options.fromfile == False and options.frombitlog == False:
_threading.Thread(target=self.watchRef).start()
self.initialized = True
print "DS-SDR Initialized"
def _build_gui(self, vbox):
def _form_set_freq(kv):
return self.set_freq(kv['freq'])
def _form_set_dm(kv):
return self.set_dm(kv['DM'])
def _form_set_doppler(kv):
return self.set_doppler(kv['Doppler'])
# Position the FFT or Waterfall
vbox.Add(self.scope.win, 5, wx.EXPAND)
vbox.Add(self.chart.win, 5, wx.EXPAND)
# add control area at the bottom
self.myform = myform = form.form()
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((7,0), 0, wx.EXPAND)
vbox1 = wx.BoxSizer(wx.VERTICAL)
myform['freq'] = form.float_field(
parent=self.panel, sizer=vbox1, label="Center freq", weight=1,
callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg))
vbox1.Add((3,0), 0, 0)
# To show current Local Mean Sidereal Time
myform['lmst_high'] = form.static_text_field(
parent=self.panel, sizer=vbox1, label="Current LMST", weight=1)
vbox1.Add((3,0), 0, 0)
# To show current spectral cursor data
myform['spec_data'] = form.static_text_field(
parent=self.panel, sizer=vbox1, label="Pulse Freq", weight=1)
vbox1.Add((3,0), 0, 0)
# To show best pulses found in FFT output
myform['best_pulse'] = form.static_text_field(
parent=self.panel, sizer=vbox1, label="Best freq", weight=1)
vbox1.Add((3,0), 0, 0)
vboxBogus = wx.BoxSizer(wx.VERTICAL)
vboxBogus.Add ((2,0), 0, wx.EXPAND)
vbox2 = wx.BoxSizer(wx.VERTICAL)
g = self.subdev.gain_range()
myform['gain'] = form.slider_field(parent=self.panel, sizer=vbox2, label="RF Gain",
weight=1,
min=int(g[0]), max=int(g[1]),
callback=self.set_gain)
vbox2.Add((6,0), 0, 0)
myform['average'] = form.slider_field(parent=self.panel, sizer=vbox2,
label="Spectral Averaging", weight=1, min=1, max=200, callback=self.set_averaging)
vbox2.Add((6,0), 0, 0)
myform['foldavg'] = form.slider_field(parent=self.panel, sizer=vbox2,
label="Folder Averaging", weight=1, min=1, max=20, callback=self.set_folder_averaging)
vbox2.Add((6,0), 0, 0)
#myform['volume'] = form.quantized_slider_field(parent=self.panel, sizer=vbox2,
#label="Audio Volume", weight=1, range=(-20, 0, 0.5), callback=self.set_volume)
#vbox2.Add((6,0), 0, 0)
myform['DM'] = form.float_field(
parent=self.panel, sizer=vbox2, label="DM", weight=1,
callback=myform.check_input_and_call(_form_set_dm))
vbox2.Add((6,0), 0, 0)
myform['Doppler'] = form.float_field(
parent=self.panel, sizer=vbox2, label="Doppler", weight=1,
callback=myform.check_input_and_call(_form_set_doppler))
vbox2.Add((6,0), 0, 0)
# Baseband recording control
buttonbox = wx.BoxSizer(wx.HORIZONTAL)
self.record_control = form.button_with_callback(self.panel,
label="Recording baseband: Off ",
callback=self.toggle_recording)
self.record_pulse_control = form.button_with_callback(self.panel,
label="Recording pulses: Off ",
callback=self.toggle_pulse_recording)
buttonbox.Add(self.record_control, 0, wx.CENTER)
buttonbox.Add(self.record_pulse_control, 0, wx.CENTER)
vbox.Add(buttonbox, 0, wx.CENTER)
hbox.Add(vbox1, 0, 0)
hbox.Add(vboxBogus, 0, 0)
hbox.Add(vbox2, wx.ALIGN_RIGHT, 0)
vbox.Add(hbox, 0, wx.EXPAND)
self._build_subpanel(vbox)
self.lmst_timer = wx.PyTimer(self.lmst_timeout)
self.lmst_timeout()
def make_control(self):
bspace = 10
vbox = wx.BoxSizer(wx.VERTICAL)
""" Frequency """
nbox = wx.BoxSizer(wx.HORIZONTAL)
self.make_label("Carrier Frequency", nbox, 46)
self.freq = form.float_field (self, nbox, \
value=default_control_setup.d_options['freq'], callback=self.SetFreq)
self.AddParam('freq',self.SetFreq)
self.SetParam('freq', self.options.freq)
vbox.AddSpacer((10,10) )
vbox.Add(nbox, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
""" Sample Rate """
nbox = wx.BoxSizer(wx.HORIZONTAL)
self.make_label("Sample Rate", nbox, 80)
self.sample_rate = form.float_field (self, nbox, \
value=self.options.sample_rate, callback=self.SetSampleRate)
self.AddParam('sample_rate', self.SetSampleRate)
self.SetParam('sample_rate', self.options.sample_rate)
vbox.Add(nbox, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
""" Upsampling Factor """
nbox = wx.BoxSizer(wx.HORIZONTAL)
self.make_label("Upsampling Factor", nbox, 43)
self.upsample = form.int_field (self, nbox, \
value=self.options.upsample, callback=self.SetUpsample)
self.AddParam('upsampling_factor', self.SetUpsample)
self.SetParam('upsampling_factor', self.options.upsample)
vbox.Add(nbox, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
self.upsamplebox = nbox
""" TxGain """
box = wx.BoxSizer(wx.HORIZONTAL)
self.txgain = form.slider_field(self, box, "Transmit Gain",\
value=self.options.tx_gain, callback=self.SetTxGain,
min=0, max=10000.0)
box.AddSpacer((10,10) )
self.autotxgain = form.checkbox_field(self, box, "auto", \
value=self.options.auto_tx_gain, callback=self.SetAutoTxGain, \
weight=0)
box.GetItem(self.autotxgain.f).SetFlag(wx.ALIGN_LEFT|wx.ALIGN_BOTTOM)
self.AddParam('auto_tx_gain', self.SetAutoTxGain)
self.SetParam('auto_tx_gain', self.options.auto_tx_gain)
self.AddParam('tx_gain', self.SetTxGain)
self.SetParam('tx_gain', self.options.tx_gain)
vbox.Add(box, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
self.txgainbox = box
""" RxGain """
box = wx.BoxSizer(wx.HORIZONTAL)
self.rxgain = form.slider_field(self, box, "Receive Gain", \
value=self.options.rx_gain, callback=self.SetRxGain,
min=0, max=75)
self.AddParam('rx_gain', self.SetRxGain)
self.SetParam('rx_gain', self.options.rx_gain)
vbox.Add(box, 0, wx.ALIGN_LEFT|wx.BOTTOM|wx.LEFT|wx.RIGHT, border=bspace)
self.topbox.Add(vbox, 0, wx.GROW)
self.cbox = vbox
self.Fit()
def _build_gui(self, vbox): def _form_set_freq(kv): # Adjust current SETI frequency, and limits self.setifreq_lower = kv['freq'] - (self.seti_freq_range/2) self.setifreq_current = kv['freq'] self.setifreq_upper = kv['freq'] + (self.seti_freq_range/2) # Reset SETI analysis timer self.seti_then = time.time() # Zero-out hits array when changing frequency self.hits_array[:,:] = 0.0 self.hit_intensities[:,:] = -60.0 return self.set_freq(kv['freq']) def _form_set_decln(kv): return self.set_decln(kv['decln']) # Position the FFT display vbox.Add(self.scope.win, 15, wx.EXPAND) if self.setimode == False: # Position the Total-power stripchart vbox.Add(self.chart.win, 15, wx.EXPAND) # add control area at the bottom self.myform = myform = form.form() hbox = wx.BoxSizer(wx.HORIZONTAL) hbox.Add((7,0), 0, wx.EXPAND) vbox1 = wx.BoxSizer(wx.VERTICAL) myform['freq'] = form.float_field( parent=self.panel, sizer=vbox1, label="Center freq", weight=1, callback=myform.check_input_and_call(_form_set_freq, self._set_status_msg)) vbox1.Add((4,0), 0, 0) myform['lmst_high'] = form.static_text_field( parent=self.panel, sizer=vbox1, label="Current LMST", weight=1) vbox1.Add((4,0), 0, 0) if self.setimode == False: myform['spec_data'] = form.static_text_field( parent=self.panel, sizer=vbox1, label="Spectral Cursor", weight=1) vbox1.Add((4,0), 0, 0) vbox2 = wx.BoxSizer(wx.VERTICAL) if self.setimode == False: vbox3 = wx.BoxSizer(wx.VERTICAL) g = self.subdev[0].gain_range() myform['gain'] = form.slider_field(parent=self.panel, sizer=vbox2, label="RF Gain", weight=1, min=int(g[0]), max=int(g[1]), callback=self.set_gain) vbox2.Add((4,0), 0, 0) if self.setimode == True: max_savg = 100 else: max_savg = 3000 myform['average'] = form.slider_field(parent=self.panel, sizer=vbox2, label="Spectral Averaging (FFT frames)", weight=1, min=1, max=max_savg, callback=self.set_averaging) # Set up scan control button when in SETI mode if (self.setimode == True): # SETI scanning control buttonbox = wx.BoxSizer(wx.HORIZONTAL) self.scan_control = form.button_with_callback(self.panel, label="Scan: On ", callback=self.toggle_scanning) buttonbox.Add(self.scan_control, 0, wx.CENTER) vbox2.Add(buttonbox, 0, wx.CENTER) vbox2.Add((4,0), 0, 0) if self.setimode == False: myform['integration'] = form.slider_field(parent=self.panel, sizer=vbox2, label="Continuum Integration Time (sec)", weight=1, min=1, max=180, callback=self.set_integration) vbox2.Add((4,0), 0, 0) myform['decln'] = form.float_field( parent=self.panel, sizer=vbox2, label="Current Declination", weight=1, callback=myform.check_input_and_call(_form_set_decln)) vbox2.Add((4,0), 0, 0) if self.setimode == False: myform['offset'] = form.slider_field(parent=self.panel, sizer=vbox3, label="Post-Detector Offset", weight=1, min=-750, max=750, callback=self.set_pd_offset) vbox3.Add((2,0), 0, 0) myform['dcgain'] = form.slider_field(parent=self.panel, sizer=vbox3, label="Post-Detector Gain", weight=1, min=1, max=100, callback=self.set_pd_gain) vbox3.Add((2,0), 0, 0) hbox.Add(vbox1, 0, 0) hbox.Add(vbox2, wx.ALIGN_RIGHT, 0) if self.setimode == False: hbox.Add(vbox3, wx.ALIGN_RIGHT, 0) vbox.Add(hbox, 0, wx.EXPAND) self._build_subpanel(vbox) self.lmst_timer = wx.PyTimer(self.lmst_timeout) self.other_timer = wx.PyTimer(self.other_timeout)
