1#!/usr/local/bin/python3.8 2################################################## 3# GNU Radio Python Flow Graph 4# Copyright 2014 National Instruments 5# 6# Title: Mega FFT 7# Description: Standard edition, dual-channel 8# Generated: Sun Jul 26 20:09:53 2015 9################################################## 10 11if __name__ == '__main__': 12 import ctypes 13 import sys 14 if sys.platform.startswith('linux'): 15 try: 16 x11 = ctypes.cdll.LoadLibrary('libX11.so') 17 x11.XInitThreads() 18 except: 19 print "Warning: failed to XInitThreads()" 20 21from gnuradio import analog 22from gnuradio import blocks 23from gnuradio import eng_notation 24from gnuradio import gr 25from gnuradio import uhd 26from gnuradio import wxgui 27from gnuradio.eng_option import eng_option 28from gnuradio.fft import logpwrfft 29from gnuradio.fft import window 30from gnuradio.fft import window as fft_win 31from gnuradio.filter import firdes 32from gnuradio.wxgui import fftsink2 33from gnuradio.wxgui import forms 34from gnuradio.wxgui import scopesink2 35from gnuradio.wxgui import waterfallsink2 36from grc_gnuradio import blks2 as grc_blks2 37from grc_gnuradio import wxgui as grc_wxgui 38from optparse import OptionParser 39import math 40import threading 41import time 42import time, datetime 43import wx 44 45class mega_fft_2ch(grc_wxgui.top_block_gui): 46 47 def __init__(self, antenna="", args="", ave=1*0 + 0.5, averaging="True", bw=0, dyn_rng=130, fft_rate=15, fft_ref_scale=2.0, fft_size=1024, freq=0 + 100e6, freq_fine_range=2e6, gain=float("-inf"), lo_check_interval=5, lo_offset=0, mag_alpha=1e-3, peak_hold="False", pps='', probe_interval=3, rate=1e6, ref='', ref_lvl=0, sensor_interval=2, show_stream_tags="False", spec='', stream_args="", window="auto", wire_format=""): 48 grc_wxgui.top_block_gui.__init__(self, title="Mega FFT") 49 50 ################################################## 51 # Parameters 52 ################################################## 53 self.antenna = antenna 54 self.args = args 55 self.ave = ave 56 self.averaging = averaging 57 self.bw = bw 58 self.dyn_rng = dyn_rng 59 self.fft_rate = fft_rate 60 self.fft_ref_scale = fft_ref_scale 61 self.fft_size = fft_size 62 self.freq = freq 63 self.freq_fine_range = freq_fine_range 64 self.gain = gain 65 self.lo_check_interval = lo_check_interval 66 self.lo_offset = lo_offset 67 self.mag_alpha = mag_alpha 68 self.peak_hold = peak_hold 69 self.pps = pps 70 self.probe_interval = probe_interval 71 self.rate = rate 72 self.ref = ref 73 self.ref_lvl = ref_lvl 74 self.sensor_interval = sensor_interval 75 self.show_stream_tags = show_stream_tags 76 self.spec = spec 77 self.stream_args = stream_args 78 self.window = window 79 self.wire_format = wire_format 80 81 ################################################## 82 # Variables 83 ################################################## 84 self.relative_freq = relative_freq = 1 85 self.gain_range = gain_range = uhd.gain_range(0,0,0) 86 self.fft_max_idx = fft_max_idx = (fft_size/2)*0 87 self.actual_sample_rate = actual_sample_rate = rate 88 self.actual_center_freq = actual_center_freq = 0 89 self.str_to_bool = str_to_bool = lambda x: len(x)>0 and x.lower()[0] not in ['0', 'n', 'f'] 90 self.signal_probe = signal_probe = 0.0 91 self.samp_rate = samp_rate = int(actual_sample_rate) 92 self.requested_freq_txt = requested_freq_txt = freq 93 self.gain_default = gain_default = gain_range.start() 94 self.freq_fine = freq_fine = 0 95 self.fft_max_idx_norm = fft_max_idx_norm = [fft_max_idx,fft_max_idx-fft_size][int(fft_max_idx>(fft_size/2))] 96 self.fft_center_freq = fft_center_freq = actual_center_freq * relative_freq 97 self.antennas = antennas = [''] 98 self.window_fn_name_map = window_fn_name_map = {'auto': 'Auto', 'bh': 'Blackman-Harris', 'ham': 'Hamming', 'han': 'Hanning', 'rect': 'Rectangular', 'flat': 'Flattop'} 99 self.window_fn_map = window_fn_map = {'auto': None, 'bh': fft_win.blackmanharris, 'ham': fft_win.hamming, 'han': fft_win.hanning, 'rect': fft_win.rectangular, 'flat': fft_win.flattop} 100 self.usrp_info = usrp_info = '(unknown)' 101 self.tune_result = tune_result = uhd.tune_result_t() 102 self.tune_mode = tune_mode = [1,0][lo_offset==0.0] 103 self.time_probe = time_probe = uhd.time_spec_t() 104 self.test = test = 1 105 self.subdev_spec = subdev_spec = '(unknown)' 106 self.signal_probe_log = signal_probe_log = math.log10([signal_probe,1.0][signal_probe==0.0])*10 107 self.selected_gain = selected_gain = gain_default 108 self.selected_antenna = selected_antenna = [ [antenna,antennas[0]][antenna not in antennas] ,antennas[0]][antenna==''] 109 self.requested_sample_rate_base = requested_sample_rate_base = rate 110 self.requested_freq = requested_freq = requested_freq_txt + freq_fine 111 self.relative_time = relative_time = True 112 self.motherboard_sensors = motherboard_sensors = '(none)' 113 self.max_bin_freq = max_bin_freq = fft_center_freq + (((1.0*fft_max_idx_norm) / fft_size) * samp_rate) 114 self.locked_probe = locked_probe = '(unknown)' 115 self.lo_offset_txt = lo_offset_txt = lo_offset 116 self.fft_peak_hold = fft_peak_hold = str_to_bool(peak_hold) 117 self.fft_max_lvl_2 = fft_max_lvl_2 = 0.0 118 self.fft_max_lvl = fft_max_lvl = 0.0 119 self.fft_averaging = fft_averaging = str_to_bool(averaging) 120 self.decim = decim = 1 121 self.daughterboard_sensors = daughterboard_sensors = '(none)' 122 self.clicked_freq = clicked_freq = 0 123 self.window_fn = window_fn = window_fn_map[window] 124 self.variable_static_usrp_info = variable_static_usrp_info = usrp_info 125 self.variable_static_time_now = variable_static_time_now = str( [time.ctime(time_probe.get_real_secs()), datetime.timedelta(seconds=time_probe.get_real_secs()), time.gmtime(time_probe.get_real_secs())] [relative_time]) 126 self.variable_static_text_0_0 = variable_static_text_0_0 = daughterboard_sensors 127 self.variable_static_text_0 = variable_static_text_0 = motherboard_sensors 128 self.variable_static_subdev_spec = variable_static_subdev_spec = subdev_spec 129 self.variable_static_rf_freq = variable_static_rf_freq = tune_result.actual_rf_freq 130 self.variable_static_requested_freq = variable_static_requested_freq = requested_freq 131 self.variable_static_max_bin_freq = variable_static_max_bin_freq = max_bin_freq 132 self.variable_static_level_probe = variable_static_level_probe = signal_probe_log 133 self.variable_static_fft_window_name = variable_static_fft_window_name = window_fn_name_map[window] 134 self.variable_static_fft_max_lvl_log = variable_static_fft_max_lvl_log = fft_max_lvl 135 self.variable_static_actual_sample_rate = variable_static_actual_sample_rate = actual_sample_rate 136 self.variable_static_actual_dsp_freq = variable_static_actual_dsp_freq = tune_result.actual_dsp_freq 137 self.variable_any_code_waterfall_ave = variable_any_code_waterfall_ave = fft_averaging 138 self.variable_any_code_iq_correction = variable_any_code_iq_correction = None 139 self.variable_any_code_fft_sink_peak_hold = variable_any_code_fft_sink_peak_hold = fft_peak_hold 140 self.variable_any_code_fft_sink_ave = variable_any_code_fft_sink_ave = fft_averaging 141 self.variable_any_code_auto_dc_offset_removal = variable_any_code_auto_dc_offset_removal = None 142 self.update_time_source = update_time_source = None 143 self.update_clock_source = update_clock_source = None 144 self.tune_obj = tune_obj = [requested_freq, uhd.tune_request(requested_freq, lo_offset_txt), uhd.tune_request(requested_freq, dsp_freq=0, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)][tune_mode] 145 self.static_locked = static_locked = '"' + str(locked_probe) + '"' 146 self.show_stream_tags_chk = show_stream_tags_chk = [False, True][show_stream_tags.lower() != 'false'] 147 self.show_max_lvl = show_max_lvl = True 148 self.show_max_freq = show_max_freq = True 149 self.selected_gain_proxy = selected_gain_proxy = selected_gain 150 self.selected_antenna_proxy = selected_antenna_proxy = selected_antenna 151 self.scope_mode_2 = scope_mode_2 = 0+1 152 self.scope_mode = scope_mode = 0+1 153 self.requested_sample_rate = requested_sample_rate = requested_sample_rate_base / (1.*decim) 154 self.motherboard_sensor_names = motherboard_sensor_names = [] 155 self.max_decim = max_decim = 256 156 self.initial_gain = initial_gain = 0 157 self.has_lo_locked = has_lo_locked = False 158 self.freq_range = freq_range = uhd.freq_range(freq,freq+1) 159 self.fix_invalid_freq = fix_invalid_freq = None 160 self.fft_max_lvl_value_2 = fft_max_lvl_value_2 = fft_max_lvl_2 161 self.fft_max_lvl_value = fft_max_lvl_value = fft_max_lvl 162 self.fft_ave_probe = fft_ave_probe = ave 163 self.daughterboard_sensor_names = daughterboard_sensor_names = [] 164 self.clicked_freq_txt = clicked_freq_txt = clicked_freq 165 self.auto_iq_correction = auto_iq_correction = True 166 self.auto_dc_offset_removal = auto_dc_offset_removal = True 167 self.any_test_1 = any_test_1 = test 168 169 ################################################## 170 # Blocks 171 ################################################## 172 self.src = uhd.usrp_source( 173 ",".join((args, "")), 174 uhd.stream_args( 175 cpu_format="fc32", 176 channels=range(2), 177 ), 178 179 ) 180 if spec != "": self.src.set_subdev_spec(spec, 0) 181 self.src.set_samp_rate(requested_sample_rate) 182 self.src.set_center_freq(uhd.tune_request(freq, lo_offset), 0) 183 self.src.set_gain(selected_gain_proxy, 0) 184 self.src.set_center_freq(uhd.tune_request(freq, lo_offset), 1) 185 self.src.set_gain(selected_gain_proxy, 1) 186 self.nb_right = self.nb_right = wx.Notebook(self.GetWin(), style=wx.NB_TOP) 187 self.nb_right.AddPage(grc_wxgui.Panel(self.nb_right), "Params") 188 self.GridAdd(self.nb_right, 0, 1, 1, 1) 189 self.nb = self.nb = wx.Notebook(self.GetWin(), style=wx.NB_TOP) 190 self.nb.AddPage(grc_wxgui.Panel(self.nb), "FFT") 191 self.nb.AddPage(grc_wxgui.Panel(self.nb), "Scope") 192 self.nb.AddPage(grc_wxgui.Panel(self.nb), "Waterfall") 193 self.nb.AddPage(grc_wxgui.Panel(self.nb), "Sensors") 194 self.GridAdd(self.nb, 0, 0, 1, 1) 195 self.nb_test = self.nb_test = wx.Notebook(self.nb_right.GetPage(0).GetWin(), style=wx.NB_LEFT) 196 self.nb_test.AddPage(grc_wxgui.Panel(self.nb_test), "Test") 197 self.nb_right.GetPage(0).Add(self.nb_test) 198 self.nb_analog = self.nb_analog = wx.Notebook(self.nb_right.GetPage(0).GetWin(), style=wx.NB_LEFT) 199 self.nb_analog.AddPage(grc_wxgui.Panel(self.nb_analog), "Analog") 200 self.nb_analog.AddPage(grc_wxgui.Panel(self.nb_analog), "DC") 201 self.nb_right.GetPage(0).Add(self.nb_analog) 202 if not hasattr(self, '_post_any_code_evaluators'): 203 self._post_any_code_evaluators = [] 204 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 205 def _run_evaluators(event): 206 _post_any_code_evaluators = self._post_any_code_evaluators 207 if len(_post_any_code_evaluators) > 0: 208 for id, evaluator in _post_any_code_evaluators: 209 try: 210 evaluator() 211 except Exception, e: 212 print "Exception while running Any Code evaluator for '%s':" % (id), e 213 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 214 self._run_evaluators = _run_evaluators 215 try: 216 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 217 except: 218 pass # FIXME 219 def _run_evaluators_later(evaluator=None): 220 if evaluator is not None: 221 self._post_any_code_evaluators += [evaluator] 222 try: 223 de = wx.PyEvent() 224 de.SetEventType(wxEVT_AnyCode) 225 wx.PostEvent(self.GetWin(), de) 226 except TypeError: 227 pass 228 except AttributeError: # FIXME 229 print "Cannot post message" 230 self._run_evaluators_later = _run_evaluators_later 231 _run_evaluators_later() 232 def __post_evalutate_gain_range(): 233 self._post_any_code_evaluators += [('gain_range', lambda: self._evalutate_gain_range(**{}))] 234 def __evalutate_gain_range(*args, **kwds): 235 try: 236 self.gain_range = self.src.get_gain_range() 237 self.set_gain_range(self.gain_range) 238 except AttributeError, e: 239 print "AttributeError while evaulating gain_range:", e 240 __post_evalutate_gain_range() 241 except Exception, e: 242 print "Exception while evaluating gain_range:", e 243 self._evalutate_gain_range = __evalutate_gain_range 244 self.__post_evalutate_gain_range = __post_evalutate_gain_range 245 self._evalutate_gain_range(**{}) 246 gain_range = self.gain_range 247 self.fft_sink = fftsink2.fft_sink_c( 248 self.nb.GetPage(0).GetWin(), 249 baseband_freq=fft_center_freq, 250 y_per_div=10, 251 y_divs=int(dyn_rng/10), 252 ref_level=ref_lvl, 253 ref_scale=fft_ref_scale, 254 sample_rate=samp_rate, 255 fft_size=1024*0 + fft_size, 256 fft_rate=fft_rate, 257 average=True, 258 avg_alpha=ave, 259 title="FFT Plot", 260 peak_hold=False, fft_in=False, 261 always_run=False, 262 fft_out=False, 263 ) 264 self.nb.GetPage(0).Add(self.fft_sink.win) 265 def fft_sink_callback(x, y): 266 self.set_clicked_freq(x) 267 268 self.fft_sink.set_callback(fft_sink_callback) 269 self.waterfall_sink = waterfallsink2.waterfall_sink_c( 270 self.nb.GetPage(2).GetWin(), 271 baseband_freq=fft_center_freq, 272 dynamic_range=dyn_rng, 273 ref_level=ref_lvl, 274 ref_scale=fft_ref_scale, 275 sample_rate=samp_rate, 276 fft_size=512*0 + fft_size, 277 fft_rate=fft_rate, 278 average=True, 279 avg_alpha=ave, 280 title="Waterfall Plot", 281 fft_in=False, 282 always_run=False, 283 fft_out=False, 284 ) 285 self.nb.GetPage(2).Add(self.waterfall_sink.win) 286 def waterfall_sink_callback(x, y): 287 self.set_clicked_freq(x) 288 289 self.waterfall_sink.set_callback(waterfall_sink_callback) 290 self._test_chooser = forms.button( 291 parent=self.nb_test.GetPage(0).GetWin(), 292 value=self.test, 293 callback=self.set_test, 294 label="Test", 295 choices=[1], 296 labels=['Reset FFT average'], 297 ) 298 self.nb_test.GetPage(0).Add(self._test_chooser) 299 self._show_stream_tags_chk_check_box = forms.check_box( 300 parent=self.nb_test.GetPage(0).GetWin(), 301 value=self.show_stream_tags_chk, 302 callback=self.set_show_stream_tags_chk, 303 label="Print stream tags", 304 true=True, 305 false=False, 306 ) 307 self.nb_test.GetPage(0).GridAdd(self._show_stream_tags_chk_check_box, 0, 0, 1, 1) 308 self._scope_mode_2_chooser = forms.radio_buttons( 309 parent=self.nb.GetPage(1).GetWin(), 310 value=self.scope_mode_2, 311 callback=self.set_scope_mode_2, 312 label="Scope Mode 2", 313 choices=[0, 1], 314 labels=['Complex', 'Magnitude'], 315 style=wx.RA_HORIZONTAL, 316 ) 317 self.nb.GetPage(1).Add(self._scope_mode_2_chooser) 318 self._scope_mode_chooser = forms.radio_buttons( 319 parent=self.nb.GetPage(1).GetWin(), 320 value=self.scope_mode, 321 callback=self.set_scope_mode, 322 label="Scope Mode", 323 choices=[0, 1], 324 labels=['Complex', 'Magnitude'], 325 style=wx.RA_HORIZONTAL, 326 ) 327 self.nb.GetPage(1).Add(self._scope_mode_chooser) 328 self.probe_avg_mag = analog.probe_avg_mag_sqrd_c(0, mag_alpha) 329 self.nb_rate = self.nb_rate = wx.Notebook(self.nb_right.GetPage(0).GetWin(), style=wx.NB_LEFT) 330 self.nb_rate.AddPage(grc_wxgui.Panel(self.nb_rate), "Rate") 331 self.nb_right.GetPage(0).Add(self.nb_rate) 332 self.nb_info = self.nb_info = wx.Notebook(self.nb_right.GetPage(0).GetWin(), style=wx.NB_LEFT) 333 self.nb_info.AddPage(grc_wxgui.Panel(self.nb_info), "Info") 334 self.nb_right.GetPage(0).GridAdd(self.nb_info, 0, 0, 1, 1) 335 self.nb_freq = self.nb_freq = wx.Notebook(self.nb_right.GetPage(0).GetWin(), style=wx.NB_LEFT) 336 self.nb_freq.AddPage(grc_wxgui.Panel(self.nb_freq), "Freq") 337 self.nb_right.GetPage(0).Add(self.nb_freq) 338 if sensor_interval > 0: 339 self._motherboard_sensor_names_poll_rate = sensor_interval 340 else: 341 self._motherboard_sensor_names_poll_rate = 1 342 self._motherboard_sensor_names_enabled = sensor_interval > 0 343 def _set_motherboard_sensor_names_poll_rate(rate): 344 self._motherboard_sensor_names_enabled = rate > 0 345 if rate > 0: 346 self._motherboard_sensor_names_poll_rate = rate 347 self.set_motherboard_sensor_names_poll_rate = _set_motherboard_sensor_names_poll_rate 348 def _motherboard_sensor_names_probe(): 349 while True: 350 if self._motherboard_sensor_names_enabled: 351 val = self.src.get_mboard_sensor_names() 352 try: 353 self.set_motherboard_sensor_names(val) 354 except AttributeError: 355 pass 356 time.sleep(1.0/(self._motherboard_sensor_names_poll_rate)) 357 _motherboard_sensor_names_thread = threading.Thread(target=_motherboard_sensor_names_probe) 358 _motherboard_sensor_names_thread.daemon = True 359 _motherboard_sensor_names_thread.start() 360 if not hasattr(self, '_post_any_code_evaluators'): 361 self._post_any_code_evaluators = [] 362 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 363 def _run_evaluators(event): 364 _post_any_code_evaluators = self._post_any_code_evaluators 365 if len(_post_any_code_evaluators) > 0: 366 for id, evaluator in _post_any_code_evaluators: 367 try: 368 evaluator() 369 except Exception, e: 370 print "Exception while running Any Code evaluator for '%s':" % (id), e 371 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 372 self._run_evaluators = _run_evaluators 373 try: 374 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 375 except: 376 pass # FIXME 377 def _run_evaluators_later(evaluator=None): 378 if evaluator is not None: 379 self._post_any_code_evaluators += [evaluator] 380 try: 381 de = wx.PyEvent() 382 de.SetEventType(wxEVT_AnyCode) 383 wx.PostEvent(self.GetWin(), de) 384 except TypeError: 385 pass 386 except AttributeError: # FIXME 387 print "Cannot post message" 388 self._run_evaluators_later = _run_evaluators_later 389 _run_evaluators_later() 390 def __post_evalutate_initial_gain(): 391 self._post_any_code_evaluators += [('initial_gain', lambda: self._evalutate_initial_gain(**{'gain_range': gain_range}))] 392 def __evalutate_initial_gain(*args, **kwds): 393 try: 394 self.initial_gain = [gain,gain_range.start() + ((gain_range.stop() - gain_range.start()) * 0.25)][gain==float('-inf')] 395 self.set_initial_gain(self.initial_gain) 396 except AttributeError, e: 397 print "AttributeError while evaulating initial_gain:", e 398 __post_evalutate_initial_gain() 399 except Exception, e: 400 print "Exception while evaluating initial_gain:", e 401 self._evalutate_initial_gain = __evalutate_initial_gain 402 self.__post_evalutate_initial_gain = __post_evalutate_initial_gain 403 self._evalutate_initial_gain(**{'gain_range': gain_range}) 404 initial_gain = self.initial_gain 405 if not hasattr(self, '_post_any_code_evaluators'): 406 self._post_any_code_evaluators = [] 407 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 408 def _run_evaluators(event): 409 _post_any_code_evaluators = self._post_any_code_evaluators 410 if len(_post_any_code_evaluators) > 0: 411 for id, evaluator in _post_any_code_evaluators: 412 try: 413 evaluator() 414 except Exception, e: 415 print "Exception while running Any Code evaluator for '%s':" % (id), e 416 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 417 self._run_evaluators = _run_evaluators 418 try: 419 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 420 except: 421 pass # FIXME 422 def _run_evaluators_later(evaluator=None): 423 if evaluator is not None: 424 self._post_any_code_evaluators += [evaluator] 425 try: 426 de = wx.PyEvent() 427 de.SetEventType(wxEVT_AnyCode) 428 wx.PostEvent(self.GetWin(), de) 429 except TypeError: 430 pass 431 except AttributeError: # FIXME 432 print "Cannot post message" 433 self._run_evaluators_later = _run_evaluators_later 434 _run_evaluators_later() 435 def __post_evalutate_has_lo_locked(): 436 self._post_any_code_evaluators += [('has_lo_locked', lambda: self._evalutate_has_lo_locked(**{}))] 437 def __evalutate_has_lo_locked(*args, **kwds): 438 try: 439 self.has_lo_locked = 'lo_locked' in self.src.get_sensor_names() 440 self.set_has_lo_locked(self.has_lo_locked) 441 except AttributeError, e: 442 print "AttributeError while evaulating has_lo_locked:", e 443 __post_evalutate_has_lo_locked() 444 except Exception, e: 445 print "Exception while evaluating has_lo_locked:", e 446 self._evalutate_has_lo_locked = __evalutate_has_lo_locked 447 self.__post_evalutate_has_lo_locked = __post_evalutate_has_lo_locked 448 self._evalutate_has_lo_locked(**{}) 449 has_lo_locked = self.has_lo_locked 450 if not hasattr(self, '_post_any_code_evaluators'): 451 self._post_any_code_evaluators = [] 452 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 453 def _run_evaluators(event): 454 _post_any_code_evaluators = self._post_any_code_evaluators 455 if len(_post_any_code_evaluators) > 0: 456 for id, evaluator in _post_any_code_evaluators: 457 try: 458 evaluator() 459 except Exception, e: 460 print "Exception while running Any Code evaluator for '%s':" % (id), e 461 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 462 self._run_evaluators = _run_evaluators 463 try: 464 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 465 except: 466 pass # FIXME 467 def _run_evaluators_later(evaluator=None): 468 if evaluator is not None: 469 self._post_any_code_evaluators += [evaluator] 470 try: 471 de = wx.PyEvent() 472 de.SetEventType(wxEVT_AnyCode) 473 wx.PostEvent(self.GetWin(), de) 474 except TypeError: 475 pass 476 except AttributeError: # FIXME 477 print "Cannot post message" 478 self._run_evaluators_later = _run_evaluators_later 479 _run_evaluators_later() 480 def __post_evalutate_freq_range(): 481 self._post_any_code_evaluators += [('freq_range', lambda: self._evalutate_freq_range(**{}))] 482 def __evalutate_freq_range(*args, **kwds): 483 try: 484 self.freq_range = self.src.get_freq_range() 485 self.set_freq_range(self.freq_range) 486 except AttributeError, e: 487 print "AttributeError while evaulating freq_range:", e 488 __post_evalutate_freq_range() 489 except Exception, e: 490 print "Exception while evaluating freq_range:", e 491 self._evalutate_freq_range = __evalutate_freq_range 492 self.__post_evalutate_freq_range = __post_evalutate_freq_range 493 self._evalutate_freq_range(**{}) 494 freq_range = self.freq_range 495 self.fft_max_lvl_probe_2 = blocks.probe_signal_f() 496 if 5 > 0: 497 self._fft_ave_probe_poll_rate = 5 498 else: 499 self._fft_ave_probe_poll_rate = 1 500 self._fft_ave_probe_enabled = 5 > 0 501 def _set_fft_ave_probe_poll_rate(rate): 502 self._fft_ave_probe_enabled = rate > 0 503 if rate > 0: 504 self._fft_ave_probe_poll_rate = rate 505 self.set_fft_ave_probe_poll_rate = _set_fft_ave_probe_poll_rate 506 def _fft_ave_probe_probe(): 507 while True: 508 if self._fft_ave_probe_enabled: 509 val = self.fft_sink.win['avg_alpha'] * [1.0/self.fft_sink.win['avg_alpha'],1.0][self.fft_sink.win['average']];() 510 try: 511 self.set_fft_ave_probe(val) 512 except AttributeError: 513 pass 514 time.sleep(1.0/(self._fft_ave_probe_poll_rate)) 515 _fft_ave_probe_thread = threading.Thread(target=_fft_ave_probe_probe) 516 _fft_ave_probe_thread.daemon = True 517 _fft_ave_probe_thread.start() 518 if sensor_interval > 0: 519 self._daughterboard_sensor_names_poll_rate = sensor_interval 520 else: 521 self._daughterboard_sensor_names_poll_rate = 1 522 self._daughterboard_sensor_names_enabled = sensor_interval > 0 523 def _set_daughterboard_sensor_names_poll_rate(rate): 524 self._daughterboard_sensor_names_enabled = rate > 0 525 if rate > 0: 526 self._daughterboard_sensor_names_poll_rate = rate 527 self.set_daughterboard_sensor_names_poll_rate = _set_daughterboard_sensor_names_poll_rate 528 def _daughterboard_sensor_names_probe(): 529 while True: 530 if self._daughterboard_sensor_names_enabled: 531 val = self.src.get_sensor_names() 532 try: 533 self.set_daughterboard_sensor_names(val) 534 except AttributeError: 535 pass 536 time.sleep(1.0/(self._daughterboard_sensor_names_poll_rate)) 537 _daughterboard_sensor_names_thread = threading.Thread(target=_daughterboard_sensor_names_probe) 538 _daughterboard_sensor_names_thread.daemon = True 539 _daughterboard_sensor_names_thread.start() 540 self._auto_iq_correction_check_box = forms.check_box( 541 parent=self.nb_analog.GetPage(1).GetWin(), 542 value=self.auto_iq_correction, 543 callback=self.set_auto_iq_correction, 544 label="Auto IQ correction", 545 true=True, 546 false=False, 547 ) 548 self.nb_analog.GetPage(1).Add(self._auto_iq_correction_check_box) 549 self._auto_dc_offset_removal_check_box = forms.check_box( 550 parent=self.nb_analog.GetPage(1).GetWin(), 551 value=self.auto_dc_offset_removal, 552 callback=self.set_auto_dc_offset_removal, 553 label="Auto DC offset removal", 554 true=True, 555 false=False, 556 ) 557 self.nb_analog.GetPage(1).Add(self._auto_dc_offset_removal_check_box) 558 if not hasattr(self, '_post_any_code_evaluators'): 559 self._post_any_code_evaluators = [] 560 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 561 def _run_evaluators(event): 562 _post_any_code_evaluators = self._post_any_code_evaluators 563 if len(_post_any_code_evaluators) > 0: 564 for id, evaluator in _post_any_code_evaluators: 565 try: 566 evaluator() 567 except Exception, e: 568 print "Exception while running Any Code evaluator for '%s':" % (id), e 569 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 570 self._run_evaluators = _run_evaluators 571 try: 572 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 573 except: 574 pass # FIXME 575 def _run_evaluators_later(evaluator=None): 576 if evaluator is not None: 577 self._post_any_code_evaluators += [evaluator] 578 try: 579 de = wx.PyEvent() 580 de.SetEventType(wxEVT_AnyCode) 581 wx.PostEvent(self.GetWin(), de) 582 except TypeError: 583 pass 584 except AttributeError: # FIXME 585 print "Cannot post message" 586 self._run_evaluators_later = _run_evaluators_later 587 _run_evaluators_later() 588 def __post_evalutate_antennas(): 589 self._post_any_code_evaluators += [('antennas', lambda: self._evalutate_antennas(**{}))] 590 def __evalutate_antennas(*args, **kwds): 591 try: 592 self.antennas = self.src.get_antennas() 593 self.set_antennas(self.antennas) 594 except AttributeError, e: 595 print "AttributeError while evaulating antennas:", e 596 __post_evalutate_antennas() 597 except Exception, e: 598 print "Exception while evaluating antennas:", e 599 self._evalutate_antennas = __evalutate_antennas 600 self.__post_evalutate_antennas = __post_evalutate_antennas 601 self._evalutate_antennas(**{}) 602 antennas = self.antennas 603 self.wxgui_scopesink2_0_0 = scopesink2.scope_sink_c( 604 self.nb.GetPage(1).GetWin(), 605 title="Scope Plot 2", 606 sample_rate=samp_rate, 607 v_scale=0, 608 v_offset=0, 609 t_scale=0, 610 ac_couple=False, 611 xy_mode=False, 612 num_inputs=1, 613 trig_mode=wxgui.TRIG_MODE_AUTO, 614 y_axis_label="Counts", 615 ) 616 self.nb.GetPage(1).Add(self.wxgui_scopesink2_0_0.win) 617 self.wxgui_scopesink2_0 = scopesink2.scope_sink_c( 618 self.nb.GetPage(1).GetWin(), 619 title="Scope Plot", 620 sample_rate=samp_rate, 621 v_scale=0, 622 v_offset=0, 623 t_scale=0, 624 ac_couple=False, 625 xy_mode=False, 626 num_inputs=1, 627 trig_mode=wxgui.TRIG_MODE_AUTO, 628 y_axis_label="Counts", 629 ) 630 self.nb.GetPage(1).Add(self.wxgui_scopesink2_0.win) 631 self.waterfall_sink_0 = waterfallsink2.waterfall_sink_c( 632 self.nb.GetPage(2).GetWin(), 633 baseband_freq=fft_center_freq, 634 dynamic_range=dyn_rng, 635 ref_level=ref_lvl, 636 ref_scale=fft_ref_scale, 637 sample_rate=samp_rate, 638 fft_size=512*0 + fft_size, 639 fft_rate=fft_rate, 640 average=True, 641 avg_alpha=ave, 642 title="Waterfall Plot 2", 643 fft_in=False, 644 always_run=False, 645 fft_out=False, 646 ) 647 self.nb.GetPage(2).Add(self.waterfall_sink_0.win) 648 def waterfall_sink_0_callback(x, y): 649 self.set_clicked_freq(x) 650 651 self.waterfall_sink_0.set_callback(waterfall_sink_0_callback) 652 self._variable_static_usrp_info_static_text = forms.static_text( 653 parent=self.nb_info.GetPage(0).GetWin(), 654 value=self.variable_static_usrp_info, 655 callback=self.set_variable_static_usrp_info, 656 label="USRP", 657 converter=forms.str_converter(), 658 ) 659 self.nb_info.GetPage(0).GridAdd(self._variable_static_usrp_info_static_text, 0, 0, 1, 10) 660 self._variable_static_time_now_static_text = forms.static_text( 661 parent=self.nb_test.GetPage(0).GetWin(), 662 value=self.variable_static_time_now, 663 callback=self.set_variable_static_time_now, 664 label="Time now", 665 converter=forms.str_converter(), 666 ) 667 self.nb_test.GetPage(0).GridAdd(self._variable_static_time_now_static_text, 1, 1, 1, 2) 668 self._variable_static_text_0_0_static_text = forms.static_text( 669 parent=self.nb.GetPage(3).GetWin(), 670 value=self.variable_static_text_0_0, 671 callback=self.set_variable_static_text_0_0, 672 label="Daughterboard", 673 converter=forms.str_converter(), 674 ) 675 self.nb.GetPage(3).GridAdd(self._variable_static_text_0_0_static_text, 2, 0, 1, 1) 676 self._variable_static_text_0_static_text = forms.static_text( 677 parent=self.nb.GetPage(3).GetWin(), 678 value=self.variable_static_text_0, 679 callback=self.set_variable_static_text_0, 680 label="Motherboard", 681 converter=forms.str_converter(), 682 ) 683 self.nb.GetPage(3).GridAdd(self._variable_static_text_0_static_text, 0, 0, 1, 1) 684 self._variable_static_subdev_spec_static_text = forms.static_text( 685 parent=self.nb_info.GetPage(0).GetWin(), 686 value=self.variable_static_subdev_spec, 687 callback=self.set_variable_static_subdev_spec, 688 label="Sub-device", 689 converter=forms.str_converter(), 690 ) 691 self.nb_info.GetPage(0).GridAdd(self._variable_static_subdev_spec_static_text, 1, 0, 1, 1) 692 self._variable_static_rf_freq_static_text = forms.static_text( 693 parent=self.nb_freq.GetPage(0).GetWin(), 694 value=self.variable_static_rf_freq, 695 callback=self.set_variable_static_rf_freq, 696 label="Actual RF freq", 697 converter=forms.float_converter(), 698 ) 699 self.nb_freq.GetPage(0).GridAdd(self._variable_static_rf_freq_static_text, 5, 0, 1, 1) 700 self._variable_static_requested_freq_static_text = forms.static_text( 701 parent=self.nb_freq.GetPage(0).GetWin(), 702 value=self.variable_static_requested_freq, 703 callback=self.set_variable_static_requested_freq, 704 label="Requested base + fine freq", 705 converter=forms.float_converter(), 706 ) 707 self.nb_freq.GetPage(0).GridAdd(self._variable_static_requested_freq_static_text, 3, 0, 1, 1) 708 self._variable_static_max_bin_freq_static_text = forms.static_text( 709 parent=self.nb_test.GetPage(0).GetWin(), 710 value=self.variable_static_max_bin_freq, 711 callback=self.set_variable_static_max_bin_freq, 712 label="Peak freq", 713 converter=forms.float_converter(), 714 ) 715 self.nb_test.GetPage(0).Add(self._variable_static_max_bin_freq_static_text) 716 self._variable_static_level_probe_static_text = forms.static_text( 717 parent=self.nb_test.GetPage(0).GetWin(), 718 value=self.variable_static_level_probe, 719 callback=self.set_variable_static_level_probe, 720 label="Signal mag^2 (dB)", 721 converter=forms.float_converter(), 722 ) 723 self.nb_test.GetPage(0).Add(self._variable_static_level_probe_static_text) 724 self._variable_static_fft_window_name_static_text = forms.static_text( 725 parent=self.nb_info.GetPage(0).GetWin(), 726 value=self.variable_static_fft_window_name, 727 callback=self.set_variable_static_fft_window_name, 728 label="FFT window", 729 converter=forms.str_converter(), 730 ) 731 self.nb_info.GetPage(0).Add(self._variable_static_fft_window_name_static_text) 732 self._variable_static_fft_max_lvl_log_static_text = forms.static_text( 733 parent=self.nb_test.GetPage(0).GetWin(), 734 value=self.variable_static_fft_max_lvl_log, 735 callback=self.set_variable_static_fft_max_lvl_log, 736 label="Peak magnitude (dB)", 737 converter=forms.float_converter(), 738 ) 739 self.nb_test.GetPage(0).Add(self._variable_static_fft_max_lvl_log_static_text) 740 self._variable_static_actual_sample_rate_static_text = forms.static_text( 741 parent=self.nb_rate.GetPage(0).GetWin(), 742 value=self.variable_static_actual_sample_rate, 743 callback=self.set_variable_static_actual_sample_rate, 744 label="Actual", 745 converter=forms.float_converter(), 746 ) 747 self.nb_rate.GetPage(0).GridAdd(self._variable_static_actual_sample_rate_static_text, 0, 1, 1, 1) 748 self._variable_static_actual_dsp_freq_static_text = forms.static_text( 749 parent=self.nb_freq.GetPage(0).GetWin(), 750 value=self.variable_static_actual_dsp_freq, 751 callback=self.set_variable_static_actual_dsp_freq, 752 label="Actual DSP freq", 753 converter=forms.float_converter(), 754 ) 755 self.nb_freq.GetPage(0).GridAdd(self._variable_static_actual_dsp_freq_static_text, 6, 0, 1, 1) 756 if not hasattr(self, '_post_any_code_evaluators'): 757 self._post_any_code_evaluators = [] 758 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 759 def _run_evaluators(event): 760 _post_any_code_evaluators = self._post_any_code_evaluators 761 if len(_post_any_code_evaluators) > 0: 762 for id, evaluator in _post_any_code_evaluators: 763 try: 764 evaluator() 765 except Exception, e: 766 print "Exception while running Any Code evaluator for '%s':" % (id), e 767 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 768 self._run_evaluators = _run_evaluators 769 try: 770 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 771 except: 772 pass # FIXME 773 def _run_evaluators_later(evaluator=None): 774 if evaluator is not None: 775 self._post_any_code_evaluators += [evaluator] 776 try: 777 de = wx.PyEvent() 778 de.SetEventType(wxEVT_AnyCode) 779 wx.PostEvent(self.GetWin(), de) 780 except TypeError: 781 pass 782 except AttributeError: # FIXME 783 print "Cannot post message" 784 self._run_evaluators_later = _run_evaluators_later 785 _run_evaluators_later() 786 def __post_evalutate_variable_any_code_waterfall_ave(): 787 self._post_any_code_evaluators += [('variable_any_code_waterfall_ave', lambda: self._evalutate_variable_any_code_waterfall_ave(**{'averaging': fft_averaging}))] 788 def __evalutate_variable_any_code_waterfall_ave(*args, **kwds): 789 try: 790 self.variable_any_code_waterfall_ave = self.waterfall_sink.win['average'] = fft_averaging 791 self.set_variable_any_code_waterfall_ave(self.variable_any_code_waterfall_ave) 792 except AttributeError, e: 793 print "AttributeError while evaulating variable_any_code_waterfall_ave:", e 794 __post_evalutate_variable_any_code_waterfall_ave() 795 except Exception, e: 796 print "Exception while evaluating variable_any_code_waterfall_ave:", e 797 self._evalutate_variable_any_code_waterfall_ave = __evalutate_variable_any_code_waterfall_ave 798 self.__post_evalutate_variable_any_code_waterfall_ave = __post_evalutate_variable_any_code_waterfall_ave 799 self.__post_evalutate_variable_any_code_waterfall_ave() 800 if not hasattr(self, '_post_any_code_evaluators'): 801 self._post_any_code_evaluators = [] 802 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 803 def _run_evaluators(event): 804 _post_any_code_evaluators = self._post_any_code_evaluators 805 if len(_post_any_code_evaluators) > 0: 806 for id, evaluator in _post_any_code_evaluators: 807 try: 808 evaluator() 809 except Exception, e: 810 print "Exception while running Any Code evaluator for '%s':" % (id), e 811 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 812 self._run_evaluators = _run_evaluators 813 try: 814 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 815 except: 816 pass # FIXME 817 def _run_evaluators_later(evaluator=None): 818 if evaluator is not None: 819 self._post_any_code_evaluators += [evaluator] 820 try: 821 de = wx.PyEvent() 822 de.SetEventType(wxEVT_AnyCode) 823 wx.PostEvent(self.GetWin(), de) 824 except TypeError: 825 pass 826 except AttributeError: # FIXME 827 print "Cannot post message" 828 self._run_evaluators_later = _run_evaluators_later 829 _run_evaluators_later() 830 def __post_evalutate_variable_any_code_iq_correction(): 831 self._post_any_code_evaluators += [('variable_any_code_iq_correction', lambda: self._evalutate_variable_any_code_iq_correction(**{'auto_iq_correction': auto_iq_correction}))] 832 def __evalutate_variable_any_code_iq_correction(*args, **kwds): 833 try: 834 [self.src.set_auto_iq_balance(self.auto_iq_correction), self.auto_iq_correction or self.src.set_iq_balance(0+0j)] 835 self.set_variable_any_code_iq_correction(self.variable_any_code_iq_correction) 836 except AttributeError, e: 837 print "AttributeError while evaulating variable_any_code_iq_correction:", e 838 __post_evalutate_variable_any_code_iq_correction() 839 except Exception, e: 840 print "Exception while evaluating variable_any_code_iq_correction:", e 841 self._evalutate_variable_any_code_iq_correction = __evalutate_variable_any_code_iq_correction 842 self.__post_evalutate_variable_any_code_iq_correction = __post_evalutate_variable_any_code_iq_correction 843 self._evalutate_variable_any_code_iq_correction(**{'auto_iq_correction': auto_iq_correction}) 844 variable_any_code_iq_correction = self.variable_any_code_iq_correction 845 if not hasattr(self, '_post_any_code_evaluators'): 846 self._post_any_code_evaluators = [] 847 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 848 def _run_evaluators(event): 849 _post_any_code_evaluators = self._post_any_code_evaluators 850 if len(_post_any_code_evaluators) > 0: 851 for id, evaluator in _post_any_code_evaluators: 852 try: 853 evaluator() 854 except Exception, e: 855 print "Exception while running Any Code evaluator for '%s':" % (id), e 856 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 857 self._run_evaluators = _run_evaluators 858 try: 859 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 860 except: 861 pass # FIXME 862 def _run_evaluators_later(evaluator=None): 863 if evaluator is not None: 864 self._post_any_code_evaluators += [evaluator] 865 try: 866 de = wx.PyEvent() 867 de.SetEventType(wxEVT_AnyCode) 868 wx.PostEvent(self.GetWin(), de) 869 except TypeError: 870 pass 871 except AttributeError: # FIXME 872 print "Cannot post message" 873 self._run_evaluators_later = _run_evaluators_later 874 _run_evaluators_later() 875 def __post_evalutate_variable_any_code_fft_sink_peak_hold(): 876 self._post_any_code_evaluators += [('variable_any_code_fft_sink_peak_hold', lambda: self._evalutate_variable_any_code_fft_sink_peak_hold(**{'peak_hold': fft_peak_hold}))] 877 def __evalutate_variable_any_code_fft_sink_peak_hold(*args, **kwds): 878 try: 879 self.variable_any_code_fft_sink_peak_hold = self.fft_sink.win['peak_hold'] = fft_peak_hold 880 self.set_variable_any_code_fft_sink_peak_hold(self.variable_any_code_fft_sink_peak_hold) 881 except AttributeError, e: 882 print "AttributeError while evaulating variable_any_code_fft_sink_peak_hold:", e 883 __post_evalutate_variable_any_code_fft_sink_peak_hold() 884 except Exception, e: 885 print "Exception while evaluating variable_any_code_fft_sink_peak_hold:", e 886 self._evalutate_variable_any_code_fft_sink_peak_hold = __evalutate_variable_any_code_fft_sink_peak_hold 887 self.__post_evalutate_variable_any_code_fft_sink_peak_hold = __post_evalutate_variable_any_code_fft_sink_peak_hold 888 self._evalutate_variable_any_code_fft_sink_peak_hold(**{'peak_hold': fft_peak_hold}) 889 variable_any_code_fft_sink_peak_hold = self.variable_any_code_fft_sink_peak_hold 890 if not hasattr(self, '_post_any_code_evaluators'): 891 self._post_any_code_evaluators = [] 892 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 893 def _run_evaluators(event): 894 _post_any_code_evaluators = self._post_any_code_evaluators 895 if len(_post_any_code_evaluators) > 0: 896 for id, evaluator in _post_any_code_evaluators: 897 try: 898 evaluator() 899 except Exception, e: 900 print "Exception while running Any Code evaluator for '%s':" % (id), e 901 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 902 self._run_evaluators = _run_evaluators 903 try: 904 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 905 except: 906 pass # FIXME 907 def _run_evaluators_later(evaluator=None): 908 if evaluator is not None: 909 self._post_any_code_evaluators += [evaluator] 910 try: 911 de = wx.PyEvent() 912 de.SetEventType(wxEVT_AnyCode) 913 wx.PostEvent(self.GetWin(), de) 914 except TypeError: 915 pass 916 except AttributeError: # FIXME 917 print "Cannot post message" 918 self._run_evaluators_later = _run_evaluators_later 919 _run_evaluators_later() 920 def __post_evalutate_variable_any_code_fft_sink_ave(): 921 self._post_any_code_evaluators += [('variable_any_code_fft_sink_ave', lambda: self._evalutate_variable_any_code_fft_sink_ave(**{'averaging': fft_averaging}))] 922 def __evalutate_variable_any_code_fft_sink_ave(*args, **kwds): 923 try: 924 self.variable_any_code_fft_sink_ave = self.fft_sink.win['average'] = fft_averaging 925 self.set_variable_any_code_fft_sink_ave(self.variable_any_code_fft_sink_ave) 926 except AttributeError, e: 927 print "AttributeError while evaulating variable_any_code_fft_sink_ave:", e 928 __post_evalutate_variable_any_code_fft_sink_ave() 929 except Exception, e: 930 print "Exception while evaluating variable_any_code_fft_sink_ave:", e 931 self._evalutate_variable_any_code_fft_sink_ave = __evalutate_variable_any_code_fft_sink_ave 932 self.__post_evalutate_variable_any_code_fft_sink_ave = __post_evalutate_variable_any_code_fft_sink_ave 933 self.__post_evalutate_variable_any_code_fft_sink_ave() 934 if not hasattr(self, '_post_any_code_evaluators'): 935 self._post_any_code_evaluators = [] 936 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 937 def _run_evaluators(event): 938 _post_any_code_evaluators = self._post_any_code_evaluators 939 if len(_post_any_code_evaluators) > 0: 940 for id, evaluator in _post_any_code_evaluators: 941 try: 942 evaluator() 943 except Exception, e: 944 print "Exception while running Any Code evaluator for '%s':" % (id), e 945 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 946 self._run_evaluators = _run_evaluators 947 try: 948 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 949 except: 950 pass # FIXME 951 def _run_evaluators_later(evaluator=None): 952 if evaluator is not None: 953 self._post_any_code_evaluators += [evaluator] 954 try: 955 de = wx.PyEvent() 956 de.SetEventType(wxEVT_AnyCode) 957 wx.PostEvent(self.GetWin(), de) 958 except TypeError: 959 pass 960 except AttributeError: # FIXME 961 print "Cannot post message" 962 self._run_evaluators_later = _run_evaluators_later 963 _run_evaluators_later() 964 def __post_evalutate_variable_any_code_auto_dc_offset_removal(): 965 self._post_any_code_evaluators += [('variable_any_code_auto_dc_offset_removal', lambda: self._evalutate_variable_any_code_auto_dc_offset_removal(**{'auto_dc_offset_removal': auto_dc_offset_removal}))] 966 def __evalutate_variable_any_code_auto_dc_offset_removal(*args, **kwds): 967 try: 968 [self.src.set_auto_dc_offset(self.auto_dc_offset_removal), self.auto_dc_offset_removal or self.src.set_dc_offset(0+0j)] 969 self.set_variable_any_code_auto_dc_offset_removal(self.variable_any_code_auto_dc_offset_removal) 970 except AttributeError, e: 971 print "AttributeError while evaulating variable_any_code_auto_dc_offset_removal:", e 972 __post_evalutate_variable_any_code_auto_dc_offset_removal() 973 except Exception, e: 974 print "Exception while evaluating variable_any_code_auto_dc_offset_removal:", e 975 self._evalutate_variable_any_code_auto_dc_offset_removal = __evalutate_variable_any_code_auto_dc_offset_removal 976 self.__post_evalutate_variable_any_code_auto_dc_offset_removal = __post_evalutate_variable_any_code_auto_dc_offset_removal 977 self._evalutate_variable_any_code_auto_dc_offset_removal(**{'auto_dc_offset_removal': auto_dc_offset_removal}) 978 variable_any_code_auto_dc_offset_removal = self.variable_any_code_auto_dc_offset_removal 979 if not hasattr(self, '_post_any_code_evaluators'): 980 self._post_any_code_evaluators = [] 981 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 982 def _run_evaluators(event): 983 _post_any_code_evaluators = self._post_any_code_evaluators 984 if len(_post_any_code_evaluators) > 0: 985 for id, evaluator in _post_any_code_evaluators: 986 try: 987 evaluator() 988 except Exception, e: 989 print "Exception while running Any Code evaluator for '%s':" % (id), e 990 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 991 self._run_evaluators = _run_evaluators 992 try: 993 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 994 except: 995 pass # FIXME 996 def _run_evaluators_later(evaluator=None): 997 if evaluator is not None: 998 self._post_any_code_evaluators += [evaluator] 999 try: 1000 de = wx.PyEvent() 1001 de.SetEventType(wxEVT_AnyCode) 1002 wx.PostEvent(self.GetWin(), de) 1003 except TypeError: 1004 pass 1005 except AttributeError: # FIXME 1006 print "Cannot post message" 1007 self._run_evaluators_later = _run_evaluators_later 1008 _run_evaluators_later() 1009 def __post_evalutate_usrp_info(): 1010 self._post_any_code_evaluators += [('usrp_info', lambda: self._evalutate_usrp_info(**{}))] 1011 def __evalutate_usrp_info(*args, **kwds): 1012 try: 1013 self.usrp_info = '%s (\'%s\'), %s' % (self.src.get_usrp_info().get('mboard_id'), self.src.get_usrp_info().get('mboard_name'), self.src.get_usrp_info().get('rx_subdev_name')) 1014 self.set_usrp_info(self.usrp_info) 1015 except AttributeError, e: 1016 print "AttributeError while evaulating usrp_info:", e 1017 __post_evalutate_usrp_info() 1018 except Exception, e: 1019 print "Exception while evaluating usrp_info:", e 1020 self._evalutate_usrp_info = __evalutate_usrp_info 1021 self.__post_evalutate_usrp_info = __post_evalutate_usrp_info 1022 self._evalutate_usrp_info(**{}) 1023 usrp_info = self.usrp_info 1024 if not hasattr(self, '_post_any_code_evaluators'): 1025 self._post_any_code_evaluators = [] 1026 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1027 def _run_evaluators(event): 1028 _post_any_code_evaluators = self._post_any_code_evaluators 1029 if len(_post_any_code_evaluators) > 0: 1030 for id, evaluator in _post_any_code_evaluators: 1031 try: 1032 evaluator() 1033 except Exception, e: 1034 print "Exception while running Any Code evaluator for '%s':" % (id), e 1035 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1036 self._run_evaluators = _run_evaluators 1037 try: 1038 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1039 except: 1040 pass # FIXME 1041 def _run_evaluators_later(evaluator=None): 1042 if evaluator is not None: 1043 self._post_any_code_evaluators += [evaluator] 1044 try: 1045 de = wx.PyEvent() 1046 de.SetEventType(wxEVT_AnyCode) 1047 wx.PostEvent(self.GetWin(), de) 1048 except TypeError: 1049 pass 1050 except AttributeError: # FIXME 1051 print "Cannot post message" 1052 self._run_evaluators_later = _run_evaluators_later 1053 _run_evaluators_later() 1054 def __post_evalutate_update_time_source(): 1055 self._post_any_code_evaluators += [('update_time_source', lambda: self._evalutate_update_time_source(**{'pps': pps}))] 1056 def __evalutate_update_time_source(*args, **kwds): 1057 try: 1058 if self.pps != '': self.src.set_time_source(self.pps, 0); print '1 PPS =', self.pps; 1059 self.set_update_time_source(self.update_time_source) 1060 except AttributeError, e: 1061 print "AttributeError while evaulating update_time_source:", e 1062 __post_evalutate_update_time_source() 1063 except Exception, e: 1064 print "Exception while evaluating update_time_source:", e 1065 self._evalutate_update_time_source = __evalutate_update_time_source 1066 self.__post_evalutate_update_time_source = __post_evalutate_update_time_source 1067 self._evalutate_update_time_source(**{'pps': pps}) 1068 update_time_source = self.update_time_source 1069 if not hasattr(self, '_post_any_code_evaluators'): 1070 self._post_any_code_evaluators = [] 1071 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1072 def _run_evaluators(event): 1073 _post_any_code_evaluators = self._post_any_code_evaluators 1074 if len(_post_any_code_evaluators) > 0: 1075 for id, evaluator in _post_any_code_evaluators: 1076 try: 1077 evaluator() 1078 except Exception, e: 1079 print "Exception while running Any Code evaluator for '%s':" % (id), e 1080 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1081 self._run_evaluators = _run_evaluators 1082 try: 1083 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1084 except: 1085 pass # FIXME 1086 def _run_evaluators_later(evaluator=None): 1087 if evaluator is not None: 1088 self._post_any_code_evaluators += [evaluator] 1089 try: 1090 de = wx.PyEvent() 1091 de.SetEventType(wxEVT_AnyCode) 1092 wx.PostEvent(self.GetWin(), de) 1093 except TypeError: 1094 pass 1095 except AttributeError: # FIXME 1096 print "Cannot post message" 1097 self._run_evaluators_later = _run_evaluators_later 1098 _run_evaluators_later() 1099 def __post_evalutate_update_clock_source(): 1100 self._post_any_code_evaluators += [('update_clock_source', lambda: self._evalutate_update_clock_source(**{'ref': ref}))] 1101 def __evalutate_update_clock_source(*args, **kwds): 1102 try: 1103 if self.ref != '': self.src.set_clock_source(self.ref, 0); print 'Ref =', self.ref; 1104 self.set_update_clock_source(self.update_clock_source) 1105 except AttributeError, e: 1106 print "AttributeError while evaulating update_clock_source:", e 1107 __post_evalutate_update_clock_source() 1108 except Exception, e: 1109 print "Exception while evaluating update_clock_source:", e 1110 self._evalutate_update_clock_source = __evalutate_update_clock_source 1111 self.__post_evalutate_update_clock_source = __post_evalutate_update_clock_source 1112 self._evalutate_update_clock_source(**{'ref': ref}) 1113 update_clock_source = self.update_clock_source 1114 if not hasattr(self, '_post_any_code_evaluators'): 1115 self._post_any_code_evaluators = [] 1116 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1117 def _run_evaluators(event): 1118 _post_any_code_evaluators = self._post_any_code_evaluators 1119 if len(_post_any_code_evaluators) > 0: 1120 for id, evaluator in _post_any_code_evaluators: 1121 try: 1122 evaluator() 1123 except Exception, e: 1124 print "Exception while running Any Code evaluator for '%s':" % (id), e 1125 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1126 self._run_evaluators = _run_evaluators 1127 try: 1128 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1129 except: 1130 pass # FIXME 1131 def _run_evaluators_later(evaluator=None): 1132 if evaluator is not None: 1133 self._post_any_code_evaluators += [evaluator] 1134 try: 1135 de = wx.PyEvent() 1136 de.SetEventType(wxEVT_AnyCode) 1137 wx.PostEvent(self.GetWin(), de) 1138 except TypeError: 1139 pass 1140 except AttributeError: # FIXME 1141 print "Cannot post message" 1142 self._run_evaluators_later = _run_evaluators_later 1143 _run_evaluators_later() 1144 def __post_evalutate_tune_result(): 1145 self._post_any_code_evaluators += [('tune_result', lambda: self._evalutate_tune_result(**{'tune_obj': tune_obj}))] 1146 def __evalutate_tune_result(*args, **kwds): 1147 try: 1148 self.tune_result = self.src.set_center_freq(self.tune_obj) 1149 self.set_tune_result(self.tune_result) 1150 except AttributeError, e: 1151 print "AttributeError while evaulating tune_result:", e 1152 __post_evalutate_tune_result() 1153 except Exception, e: 1154 print "Exception while evaluating tune_result:", e 1155 self._evalutate_tune_result = __evalutate_tune_result 1156 self.__post_evalutate_tune_result = __post_evalutate_tune_result 1157 self._evalutate_tune_result(**{'tune_obj': tune_obj}) 1158 tune_result = self.tune_result 1159 self._tune_mode_chooser = forms.drop_down( 1160 parent=self.nb_freq.GetPage(0).GetWin(), 1161 value=self.tune_mode, 1162 callback=self.set_tune_mode, 1163 label="Tune mode", 1164 choices=[0, 1, 2], 1165 labels=['Auto (no LO offset)', 'Auto with LO offset', 'Manual (no DSP)'], 1166 ) 1167 self.nb_freq.GetPage(0).GridAdd(self._tune_mode_chooser, 0, 0, 1, 1) 1168 if sensor_interval > 0: 1169 self._time_probe_poll_rate = sensor_interval 1170 else: 1171 self._time_probe_poll_rate = 1 1172 self._time_probe_enabled = sensor_interval > 0 1173 def _set_time_probe_poll_rate(rate): 1174 self._time_probe_enabled = rate > 0 1175 if rate > 0: 1176 self._time_probe_poll_rate = rate 1177 self.set_time_probe_poll_rate = _set_time_probe_poll_rate 1178 def _time_probe_probe(): 1179 while True: 1180 if self._time_probe_enabled: 1181 val = self.src.get_time_now() 1182 try: 1183 self.set_time_probe(val) 1184 except AttributeError: 1185 pass 1186 time.sleep(1.0/(self._time_probe_poll_rate)) 1187 _time_probe_thread = threading.Thread(target=_time_probe_probe) 1188 _time_probe_thread.daemon = True 1189 _time_probe_thread.start() 1190 if not hasattr(self, '_post_any_code_evaluators'): 1191 self._post_any_code_evaluators = [] 1192 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1193 def _run_evaluators(event): 1194 _post_any_code_evaluators = self._post_any_code_evaluators 1195 if len(_post_any_code_evaluators) > 0: 1196 for id, evaluator in _post_any_code_evaluators: 1197 try: 1198 evaluator() 1199 except Exception, e: 1200 print "Exception while running Any Code evaluator for '%s':" % (id), e 1201 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1202 self._run_evaluators = _run_evaluators 1203 try: 1204 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1205 except: 1206 pass # FIXME 1207 def _run_evaluators_later(evaluator=None): 1208 if evaluator is not None: 1209 self._post_any_code_evaluators += [evaluator] 1210 try: 1211 de = wx.PyEvent() 1212 de.SetEventType(wxEVT_AnyCode) 1213 wx.PostEvent(self.GetWin(), de) 1214 except TypeError: 1215 pass 1216 except AttributeError: # FIXME 1217 print "Cannot post message" 1218 self._run_evaluators_later = _run_evaluators_later 1219 _run_evaluators_later() 1220 def __post_evalutate_subdev_spec(): 1221 self._post_any_code_evaluators += [('subdev_spec', lambda: self._evalutate_subdev_spec(**{}))] 1222 def __evalutate_subdev_spec(*args, **kwds): 1223 try: 1224 self.subdev_spec = '[' + self.src.get_subdev_spec().strip() + ']' 1225 self.set_subdev_spec(self.subdev_spec) 1226 except AttributeError, e: 1227 print "AttributeError while evaulating subdev_spec:", e 1228 __post_evalutate_subdev_spec() 1229 except Exception, e: 1230 print "Exception while evaluating subdev_spec:", e 1231 self._evalutate_subdev_spec = __evalutate_subdev_spec 1232 self.__post_evalutate_subdev_spec = __post_evalutate_subdev_spec 1233 self._evalutate_subdev_spec(**{}) 1234 subdev_spec = self.subdev_spec 1235 self._static_locked_static_text = forms.static_text( 1236 parent=self.nb_info.GetPage(0).GetWin(), 1237 value=self.static_locked, 1238 callback=self.set_static_locked, 1239 label="Locked", 1240 converter=forms.str_converter(), 1241 ) 1242 self.nb_info.GetPage(0).Add(self._static_locked_static_text) 1243 if probe_interval > 0: 1244 self._signal_probe_poll_rate = probe_interval 1245 else: 1246 self._signal_probe_poll_rate = 1 1247 self._signal_probe_enabled = probe_interval > 0 1248 def _set_signal_probe_poll_rate(rate): 1249 self._signal_probe_enabled = rate > 0 1250 if rate > 0: 1251 self._signal_probe_poll_rate = rate 1252 self.set_signal_probe_poll_rate = _set_signal_probe_poll_rate 1253 def _signal_probe_probe(): 1254 while True: 1255 if self._signal_probe_enabled: 1256 val = self.probe_avg_mag.level() 1257 try: 1258 self.set_signal_probe(val) 1259 except AttributeError: 1260 pass 1261 time.sleep(1.0/(self._signal_probe_poll_rate)) 1262 _signal_probe_thread = threading.Thread(target=_signal_probe_probe) 1263 _signal_probe_thread.daemon = True 1264 _signal_probe_thread.start() 1265 self._show_max_lvl_check_box = forms.check_box( 1266 parent=self.nb_test.GetPage(0).GetWin(), 1267 value=self.show_max_lvl, 1268 callback=self.set_show_max_lvl, 1269 label="Show max level", 1270 true=True, 1271 false=False, 1272 ) 1273 self.nb_test.GetPage(0).GridAdd(self._show_max_lvl_check_box, 0, 2, 1, 1) 1274 self._show_max_freq_check_box = forms.check_box( 1275 parent=self.nb_test.GetPage(0).GetWin(), 1276 value=self.show_max_freq, 1277 callback=self.set_show_max_freq, 1278 label="Show max freq", 1279 true=True, 1280 false=False, 1281 ) 1282 self.nb_test.GetPage(0).GridAdd(self._show_max_freq_check_box, 0, 1, 1, 1) 1283 _selected_gain_sizer = wx.BoxSizer(wx.VERTICAL) 1284 self._selected_gain_text_box = forms.text_box( 1285 parent=self.nb_analog.GetPage(0).GetWin(), 1286 sizer=_selected_gain_sizer, 1287 value=self.selected_gain, 1288 callback=self.set_selected_gain, 1289 label="Gain", 1290 converter=forms.float_converter(), 1291 proportion=0, 1292 ) 1293 self._selected_gain_slider = forms.slider( 1294 parent=self.nb_analog.GetPage(0).GetWin(), 1295 sizer=_selected_gain_sizer, 1296 value=self.selected_gain, 1297 callback=self.set_selected_gain, 1298 minimum=gain_range.start(), 1299 maximum=[gain_range.stop(), gain_range.start() + 1.0][gain_range.stop()==gain_range.start()], 1300 num_steps=[int((abs(gain_range.stop()-gain_range.start())/[gain_range.step(), 1.0][gain_range.step()==0])), 1][gain_range.stop()==gain_range.start()], 1301 style=wx.SL_HORIZONTAL, 1302 cast=float, 1303 proportion=1, 1304 ) 1305 self.nb_analog.GetPage(0).Add(_selected_gain_sizer) 1306 self._selected_antenna_chooser = forms.radio_buttons( 1307 parent=self.nb_analog.GetPage(0).GetWin(), 1308 value=self.selected_antenna, 1309 callback=self.set_selected_antenna, 1310 label="Antenna", 1311 choices=antennas, 1312 labels=[antennas,['(default)']][antennas==('',)], 1313 style=wx.RA_HORIZONTAL, 1314 ) 1315 self.nb_analog.GetPage(0).Add(self._selected_antenna_chooser) 1316 self._requested_sample_rate_base_text_box = forms.text_box( 1317 parent=self.nb_rate.GetPage(0).GetWin(), 1318 value=self.requested_sample_rate_base, 1319 callback=self.set_requested_sample_rate_base, 1320 label="Requested base sample rate", 1321 converter=forms.float_converter(), 1322 ) 1323 self.nb_rate.GetPage(0).GridAdd(self._requested_sample_rate_base_text_box, 0, 0, 1, 1) 1324 _requested_freq_txt_sizer = wx.BoxSizer(wx.VERTICAL) 1325 self._requested_freq_txt_text_box = forms.text_box( 1326 parent=self.nb_freq.GetPage(0).GetWin(), 1327 sizer=_requested_freq_txt_sizer, 1328 value=self.requested_freq_txt, 1329 callback=self.set_requested_freq_txt, 1330 label="Requested freq", 1331 converter=forms.float_converter(), 1332 proportion=0, 1333 ) 1334 self._requested_freq_txt_slider = forms.slider( 1335 parent=self.nb_freq.GetPage(0).GetWin(), 1336 sizer=_requested_freq_txt_sizer, 1337 value=self.requested_freq_txt, 1338 callback=self.set_requested_freq_txt, 1339 minimum=freq_range.start(), 1340 maximum=[freq_range.stop(), freq_range.start() + 1.0][freq_range.start()==freq_range.stop()], 1341 num_steps=[1000,1][freq_range.start()==freq_range.stop()], 1342 style=wx.SL_HORIZONTAL, 1343 cast=float, 1344 proportion=1, 1345 ) 1346 self.nb_freq.GetPage(0).GridAdd(_requested_freq_txt_sizer, 1, 0, 1, 1) 1347 self._relative_time_chooser = forms.drop_down( 1348 parent=self.nb_test.GetPage(0).GetWin(), 1349 value=self.relative_time, 1350 callback=self.set_relative_time, 1351 label="Time display", 1352 choices=[False, True], 1353 labels=['Absolute', 'Relative'], 1354 ) 1355 self.nb_test.GetPage(0).GridAdd(self._relative_time_chooser, 1, 0, 1, 1) 1356 self._relative_freq_chooser = forms.drop_down( 1357 parent=self.nb_freq.GetPage(0).GetWin(), 1358 value=self.relative_freq, 1359 callback=self.set_relative_freq, 1360 label="Frequency Axis", 1361 choices=[1, 0], 1362 labels=['RF', 'Baseband'], 1363 ) 1364 self.nb_freq.GetPage(0).GridAdd(self._relative_freq_chooser, 7, 0, 1, 1) 1365 if not hasattr(self, '_post_any_code_evaluators'): 1366 self._post_any_code_evaluators = [] 1367 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1368 def _run_evaluators(event): 1369 _post_any_code_evaluators = self._post_any_code_evaluators 1370 if len(_post_any_code_evaluators) > 0: 1371 for id, evaluator in _post_any_code_evaluators: 1372 try: 1373 evaluator() 1374 except Exception, e: 1375 print "Exception while running Any Code evaluator for '%s':" % (id), e 1376 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1377 self._run_evaluators = _run_evaluators 1378 try: 1379 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1380 except: 1381 pass # FIXME 1382 def _run_evaluators_later(evaluator=None): 1383 if evaluator is not None: 1384 self._post_any_code_evaluators += [evaluator] 1385 try: 1386 de = wx.PyEvent() 1387 de.SetEventType(wxEVT_AnyCode) 1388 wx.PostEvent(self.GetWin(), de) 1389 except TypeError: 1390 pass 1391 except AttributeError: # FIXME 1392 print "Cannot post message" 1393 self._run_evaluators_later = _run_evaluators_later 1394 _run_evaluators_later() 1395 def __post_evalutate_motherboard_sensors(): 1396 self._post_any_code_evaluators += [('motherboard_sensors', lambda: self._evalutate_motherboard_sensors(**{'motherboard_sensor_names': motherboard_sensor_names}))] 1397 def __evalutate_motherboard_sensors(*args, **kwds): 1398 try: 1399 self.motherboard_sensors = '\n'.join(map(lambda x: '%s: %s' % (x, str(self.src.get_mboard_sensor(x))), filter(lambda x: x.find('gps') != 0, self.motherboard_sensor_names))) 1400 self.set_motherboard_sensors(self.motherboard_sensors) 1401 except AttributeError, e: 1402 print "AttributeError while evaulating motherboard_sensors:", e 1403 __post_evalutate_motherboard_sensors() 1404 except Exception, e: 1405 print "Exception while evaluating motherboard_sensors:", e 1406 self._evalutate_motherboard_sensors = __evalutate_motherboard_sensors 1407 self.__post_evalutate_motherboard_sensors = __post_evalutate_motherboard_sensors 1408 self._evalutate_motherboard_sensors(**{'motherboard_sensor_names': motherboard_sensor_names}) 1409 motherboard_sensors = self.motherboard_sensors 1410 self.logpwrfft_x_0_0 = logpwrfft.logpwrfft_c( 1411 sample_rate=samp_rate, 1412 fft_size=fft_size, 1413 ref_scale=fft_ref_scale, 1414 frame_rate=fft_rate, 1415 avg_alpha=fft_ave_probe, 1416 average=False, 1417 ) 1418 self.logpwrfft_x_0 = logpwrfft.logpwrfft_c( 1419 sample_rate=samp_rate, 1420 fft_size=fft_size, 1421 ref_scale=fft_ref_scale, 1422 frame_rate=fft_rate, 1423 avg_alpha=fft_ave_probe, 1424 average=False, 1425 ) 1426 if lo_check_interval * float(has_lo_locked) > 0: 1427 self._locked_probe_poll_rate = lo_check_interval * float(has_lo_locked) 1428 else: 1429 self._locked_probe_poll_rate = 1 1430 self._locked_probe_enabled = lo_check_interval * float(has_lo_locked) > 0 1431 def _set_locked_probe_poll_rate(rate): 1432 self._locked_probe_enabled = rate > 0 1433 if rate > 0: 1434 self._locked_probe_poll_rate = rate 1435 self.set_locked_probe_poll_rate = _set_locked_probe_poll_rate 1436 def _locked_probe_probe(): 1437 while True: 1438 if self._locked_probe_enabled: 1439 val = self.src.get_sensor('lo_locked') 1440 try: 1441 self.set_locked_probe(val) 1442 except AttributeError: 1443 pass 1444 time.sleep(1.0/(self._locked_probe_poll_rate)) 1445 _locked_probe_thread = threading.Thread(target=_locked_probe_probe) 1446 _locked_probe_thread.daemon = True 1447 _locked_probe_thread.start() 1448 self._lo_offset_txt_text_box = forms.text_box( 1449 parent=self.nb_freq.GetPage(0).GetWin(), 1450 value=self.lo_offset_txt, 1451 callback=self.set_lo_offset_txt, 1452 label="LO offset (only for LO offset tuning mode)", 1453 converter=forms.float_converter(), 1454 ) 1455 self.nb_freq.GetPage(0).GridAdd(self._lo_offset_txt_text_box, 4, 0, 1, 1) 1456 if not hasattr(self, '_post_any_code_evaluators'): 1457 self._post_any_code_evaluators = [] 1458 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1459 def _run_evaluators(event): 1460 _post_any_code_evaluators = self._post_any_code_evaluators 1461 if len(_post_any_code_evaluators) > 0: 1462 for id, evaluator in _post_any_code_evaluators: 1463 try: 1464 evaluator() 1465 except Exception, e: 1466 print "Exception while running Any Code evaluator for '%s':" % (id), e 1467 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1468 self._run_evaluators = _run_evaluators 1469 try: 1470 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1471 except: 1472 pass # FIXME 1473 def _run_evaluators_later(evaluator=None): 1474 if evaluator is not None: 1475 self._post_any_code_evaluators += [evaluator] 1476 try: 1477 de = wx.PyEvent() 1478 de.SetEventType(wxEVT_AnyCode) 1479 wx.PostEvent(self.GetWin(), de) 1480 except TypeError: 1481 pass 1482 except AttributeError: # FIXME 1483 print "Cannot post message" 1484 self._run_evaluators_later = _run_evaluators_later 1485 _run_evaluators_later() 1486 def __post_evalutate_gain_default(): 1487 self._post_any_code_evaluators += [('gain_default', lambda: self._evalutate_gain_default(**{'initial_gain': initial_gain}))] 1488 def __evalutate_gain_default(*args, **kwds): 1489 try: 1490 self.gain_default = [gain,initial_gain][gain==float('-inf')] 1491 self.set_gain_default(self.gain_default) 1492 except AttributeError, e: 1493 print "AttributeError while evaulating gain_default:", e 1494 __post_evalutate_gain_default() 1495 except Exception, e: 1496 print "Exception while evaluating gain_default:", e 1497 self._evalutate_gain_default = __evalutate_gain_default 1498 self.__post_evalutate_gain_default = __post_evalutate_gain_default 1499 self._evalutate_gain_default(**{'initial_gain': initial_gain}) 1500 gain_default = self.gain_default 1501 _freq_fine_sizer = wx.BoxSizer(wx.VERTICAL) 1502 self._freq_fine_text_box = forms.text_box( 1503 parent=self.nb_freq.GetPage(0).GetWin(), 1504 sizer=_freq_fine_sizer, 1505 value=self.freq_fine, 1506 callback=self.set_freq_fine, 1507 label="Freq (fine)", 1508 converter=forms.float_converter(), 1509 proportion=0, 1510 ) 1511 self._freq_fine_slider = forms.slider( 1512 parent=self.nb_freq.GetPage(0).GetWin(), 1513 sizer=_freq_fine_sizer, 1514 value=self.freq_fine, 1515 callback=self.set_freq_fine, 1516 minimum=-freq_fine_range/2, 1517 maximum=freq_fine_range/2, 1518 num_steps=1000, 1519 style=wx.SL_HORIZONTAL, 1520 cast=float, 1521 proportion=1, 1522 ) 1523 self.nb_freq.GetPage(0).GridAdd(_freq_fine_sizer, 2, 0, 1, 1) 1524 if not hasattr(self, '_post_any_code_evaluators'): 1525 self._post_any_code_evaluators = [] 1526 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1527 def _run_evaluators(event): 1528 _post_any_code_evaluators = self._post_any_code_evaluators 1529 if len(_post_any_code_evaluators) > 0: 1530 for id, evaluator in _post_any_code_evaluators: 1531 try: 1532 evaluator() 1533 except Exception, e: 1534 print "Exception while running Any Code evaluator for '%s':" % (id), e 1535 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1536 self._run_evaluators = _run_evaluators 1537 try: 1538 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1539 except: 1540 pass # FIXME 1541 def _run_evaluators_later(evaluator=None): 1542 if evaluator is not None: 1543 self._post_any_code_evaluators += [evaluator] 1544 try: 1545 de = wx.PyEvent() 1546 de.SetEventType(wxEVT_AnyCode) 1547 wx.PostEvent(self.GetWin(), de) 1548 except TypeError: 1549 pass 1550 except AttributeError: # FIXME 1551 print "Cannot post message" 1552 self._run_evaluators_later = _run_evaluators_later 1553 _run_evaluators_later() 1554 def __post_evalutate_fix_invalid_freq(): 1555 self._post_any_code_evaluators += [('fix_invalid_freq', lambda: self._evalutate_fix_invalid_freq(**{}))] 1556 def __evalutate_fix_invalid_freq(*args, **kwds): 1557 try: 1558 ((freq <= freq_range.stop()) and (freq >= freq_range.start())) or self.set_requested_freq_txt(self.src.get_center_freq()); print self.src.get_center_freq() 1559 self.set_fix_invalid_freq(self.fix_invalid_freq) 1560 except AttributeError, e: 1561 print "AttributeError while evaulating fix_invalid_freq:", e 1562 __post_evalutate_fix_invalid_freq() 1563 except Exception, e: 1564 print "Exception while evaluating fix_invalid_freq:", e 1565 self._evalutate_fix_invalid_freq = __evalutate_fix_invalid_freq 1566 self.__post_evalutate_fix_invalid_freq = __post_evalutate_fix_invalid_freq 1567 self.__post_evalutate_fix_invalid_freq() 1568 self.fft_sink_two_1 = fftsink2.fft_sink_c( 1569 self.nb.GetPage(0).GetWin(), 1570 baseband_freq=fft_center_freq, 1571 y_per_div=10, 1572 y_divs=int(dyn_rng/10), 1573 ref_level=ref_lvl, 1574 ref_scale=fft_ref_scale, 1575 sample_rate=samp_rate, 1576 fft_size=1024*0 + fft_size, 1577 fft_rate=fft_rate, 1578 average=True, 1579 avg_alpha=ave, 1580 title="FFT Plot 2", 1581 peak_hold=False, fft_in=False, 1582 always_run=False, 1583 fft_out=False, 1584 ) 1585 self.nb.GetPage(0).Add(self.fft_sink_two_1.win) 1586 def fft_sink_two_1_callback(x, y): 1587 self.set_clicked_freq(x) 1588 1589 self.fft_sink_two_1.set_callback(fft_sink_two_1_callback) 1590 self.fft_max_lvl_probe = blocks.probe_signal_f() 1591 if probe_interval > 0: 1592 self._fft_max_lvl_2_poll_rate = probe_interval 1593 else: 1594 self._fft_max_lvl_2_poll_rate = 1 1595 self._fft_max_lvl_2_enabled = probe_interval > 0 1596 def _set_fft_max_lvl_2_poll_rate(rate): 1597 self._fft_max_lvl_2_enabled = rate > 0 1598 if rate > 0: 1599 self._fft_max_lvl_2_poll_rate = rate 1600 self.set_fft_max_lvl_2_poll_rate = _set_fft_max_lvl_2_poll_rate 1601 def _fft_max_lvl_2_probe(): 1602 while True: 1603 if self._fft_max_lvl_2_enabled: 1604 val = self.fft_max_lvl_probe_2.level() 1605 try: 1606 self.set_fft_max_lvl_2(val) 1607 except AttributeError: 1608 pass 1609 time.sleep(1.0/(self._fft_max_lvl_2_poll_rate)) 1610 _fft_max_lvl_2_thread = threading.Thread(target=_fft_max_lvl_2_probe) 1611 _fft_max_lvl_2_thread.daemon = True 1612 _fft_max_lvl_2_thread.start() 1613 if probe_interval > 0: 1614 self._fft_max_lvl_poll_rate = probe_interval 1615 else: 1616 self._fft_max_lvl_poll_rate = 1 1617 self._fft_max_lvl_enabled = probe_interval > 0 1618 def _set_fft_max_lvl_poll_rate(rate): 1619 self._fft_max_lvl_enabled = rate > 0 1620 if rate > 0: 1621 self._fft_max_lvl_poll_rate = rate 1622 self.set_fft_max_lvl_poll_rate = _set_fft_max_lvl_poll_rate 1623 def _fft_max_lvl_probe(): 1624 while True: 1625 if self._fft_max_lvl_enabled: 1626 val = self.fft_max_lvl_probe.level() 1627 try: 1628 self.set_fft_max_lvl(val) 1629 except AttributeError: 1630 pass 1631 time.sleep(1.0/(self._fft_max_lvl_poll_rate)) 1632 _fft_max_lvl_thread = threading.Thread(target=_fft_max_lvl_probe) 1633 _fft_max_lvl_thread.daemon = True 1634 _fft_max_lvl_thread.start() 1635 self.fft_max_idx_probe_0 = blocks.probe_signal_s() 1636 self.fft_max_idx_probe = blocks.probe_signal_s() 1637 if probe_interval > 0: 1638 self._fft_max_idx_poll_rate = probe_interval 1639 else: 1640 self._fft_max_idx_poll_rate = 1 1641 self._fft_max_idx_enabled = probe_interval > 0 1642 def _set_fft_max_idx_poll_rate(rate): 1643 self._fft_max_idx_enabled = rate > 0 1644 if rate > 0: 1645 self._fft_max_idx_poll_rate = rate 1646 self.set_fft_max_idx_poll_rate = _set_fft_max_idx_poll_rate 1647 def _fft_max_idx_probe(): 1648 while True: 1649 if self._fft_max_idx_enabled: 1650 val = self.fft_max_idx_probe.level() 1651 try: 1652 self.set_fft_max_idx(val) 1653 except AttributeError: 1654 pass 1655 time.sleep(1.0/(self._fft_max_idx_poll_rate)) 1656 _fft_max_idx_thread = threading.Thread(target=_fft_max_idx_probe) 1657 _fft_max_idx_thread.daemon = True 1658 _fft_max_idx_thread.start() 1659 _decim_sizer = wx.BoxSizer(wx.VERTICAL) 1660 self._decim_text_box = forms.text_box( 1661 parent=self.nb_rate.GetPage(0).GetWin(), 1662 sizer=_decim_sizer, 1663 value=self.decim, 1664 callback=self.set_decim, 1665 label="Divide base sample rate", 1666 converter=forms.int_converter(), 1667 proportion=0, 1668 ) 1669 self._decim_slider = forms.slider( 1670 parent=self.nb_rate.GetPage(0).GetWin(), 1671 sizer=_decim_sizer, 1672 value=self.decim, 1673 callback=self.set_decim, 1674 minimum=1, 1675 maximum=max_decim, 1676 num_steps=max_decim-1, 1677 style=wx.SL_HORIZONTAL, 1678 cast=int, 1679 proportion=1, 1680 ) 1681 self.nb_rate.GetPage(0).Add(_decim_sizer) 1682 if not hasattr(self, '_post_any_code_evaluators'): 1683 self._post_any_code_evaluators = [] 1684 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1685 def _run_evaluators(event): 1686 _post_any_code_evaluators = self._post_any_code_evaluators 1687 if len(_post_any_code_evaluators) > 0: 1688 for id, evaluator in _post_any_code_evaluators: 1689 try: 1690 evaluator() 1691 except Exception, e: 1692 print "Exception while running Any Code evaluator for '%s':" % (id), e 1693 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1694 self._run_evaluators = _run_evaluators 1695 try: 1696 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1697 except: 1698 pass # FIXME 1699 def _run_evaluators_later(evaluator=None): 1700 if evaluator is not None: 1701 self._post_any_code_evaluators += [evaluator] 1702 try: 1703 de = wx.PyEvent() 1704 de.SetEventType(wxEVT_AnyCode) 1705 wx.PostEvent(self.GetWin(), de) 1706 except TypeError: 1707 pass 1708 except AttributeError: # FIXME 1709 print "Cannot post message" 1710 self._run_evaluators_later = _run_evaluators_later 1711 _run_evaluators_later() 1712 def __post_evalutate_daughterboard_sensors(): 1713 self._post_any_code_evaluators += [('daughterboard_sensors', lambda: self._evalutate_daughterboard_sensors(**{'daughterboard_sensor_names': daughterboard_sensor_names}))] 1714 def __evalutate_daughterboard_sensors(*args, **kwds): 1715 try: 1716 self.daughterboard_sensors = '\n'.join(map(lambda x: '%s: %s' % (x, str(self.src.get_sensor(x))), self.daughterboard_sensor_names)) 1717 self.set_daughterboard_sensors(self.daughterboard_sensors) 1718 except AttributeError, e: 1719 print "AttributeError while evaulating daughterboard_sensors:", e 1720 __post_evalutate_daughterboard_sensors() 1721 except Exception, e: 1722 print "Exception while evaluating daughterboard_sensors:", e 1723 self._evalutate_daughterboard_sensors = __evalutate_daughterboard_sensors 1724 self.__post_evalutate_daughterboard_sensors = __post_evalutate_daughterboard_sensors 1725 self._evalutate_daughterboard_sensors(**{'daughterboard_sensor_names': daughterboard_sensor_names}) 1726 daughterboard_sensors = self.daughterboard_sensors 1727 self._clicked_freq_txt_text_box = forms.text_box( 1728 parent=self.nb_test.GetPage(0).GetWin(), 1729 value=self.clicked_freq_txt, 1730 callback=self.set_clicked_freq_txt, 1731 label="Clicked freq", 1732 converter=forms.float_converter(), 1733 ) 1734 self.nb_test.GetPage(0).Add(self._clicked_freq_txt_text_box) 1735 self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_gr_complex*1, "", ""); self.blocks_tag_debug_0.set_display(show_stream_tags_chk) 1736 self.blocks_null_sink_0_0 = blocks.null_sink(gr.sizeof_short*1) 1737 self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_short*1) 1738 self.blocks_max_xx_0_0 = blocks.max_ff(fft_size) 1739 self.blocks_max_xx_0 = blocks.max_ff(fft_size) 1740 self.blocks_float_to_complex_0_0 = blocks.float_to_complex(1) 1741 self.blocks_float_to_complex_0 = blocks.float_to_complex(1) 1742 self.blocks_complex_to_mag_0_0 = blocks.complex_to_mag(1) 1743 self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1) 1744 self.blocks_argmax_xx_0_0 = blocks.argmax_fs(fft_size) 1745 self.blocks_argmax_xx_0 = blocks.argmax_fs(fft_size) 1746 self.blks2_selector_0_1 = grc_blks2.selector( 1747 item_size=gr.sizeof_gr_complex*1, 1748 num_inputs=2, 1749 num_outputs=1, 1750 input_index=scope_mode_2, 1751 output_index=0, 1752 ) 1753 self.blks2_selector_0_0_0 = grc_blks2.selector( 1754 item_size=gr.sizeof_gr_complex*1, 1755 num_inputs=1, 1756 num_outputs=2, 1757 input_index=0, 1758 output_index=scope_mode_2, 1759 ) 1760 self.blks2_selector_0_0 = grc_blks2.selector( 1761 item_size=gr.sizeof_gr_complex*1, 1762 num_inputs=1, 1763 num_outputs=2, 1764 input_index=0, 1765 output_index=scope_mode, 1766 ) 1767 self.blks2_selector_0 = grc_blks2.selector( 1768 item_size=gr.sizeof_gr_complex*1, 1769 num_inputs=2, 1770 num_outputs=1, 1771 input_index=scope_mode, 1772 output_index=0, 1773 ) 1774 if not hasattr(self, '_post_any_code_evaluators'): 1775 self._post_any_code_evaluators = [] 1776 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1777 def _run_evaluators(event): 1778 _post_any_code_evaluators = self._post_any_code_evaluators 1779 if len(_post_any_code_evaluators) > 0: 1780 for id, evaluator in _post_any_code_evaluators: 1781 try: 1782 evaluator() 1783 except Exception, e: 1784 print "Exception while running Any Code evaluator for '%s':" % (id), e 1785 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1786 self._run_evaluators = _run_evaluators 1787 try: 1788 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1789 except: 1790 pass # FIXME 1791 def _run_evaluators_later(evaluator=None): 1792 if evaluator is not None: 1793 self._post_any_code_evaluators += [evaluator] 1794 try: 1795 de = wx.PyEvent() 1796 de.SetEventType(wxEVT_AnyCode) 1797 wx.PostEvent(self.GetWin(), de) 1798 except TypeError: 1799 pass 1800 except AttributeError: # FIXME 1801 print "Cannot post message" 1802 self._run_evaluators_later = _run_evaluators_later 1803 _run_evaluators_later() 1804 def __post_evalutate_any_test_1(): 1805 self._post_any_code_evaluators += [('any_test_1', lambda: self._evalutate_any_test_1(**{'test': test}))] 1806 def __evalutate_any_test_1(*args, **kwds): 1807 try: 1808 if self.fft_sink.controller['average']: self.fft_sink.controller['average'] = False; time.sleep(0.25); self.fft_sink.controller['average'] = True; 1809 self.set_any_test_1(self.any_test_1) 1810 except AttributeError, e: 1811 print "AttributeError while evaulating any_test_1:", e 1812 __post_evalutate_any_test_1() 1813 except Exception, e: 1814 print "Exception while evaluating any_test_1:", e 1815 self._evalutate_any_test_1 = __evalutate_any_test_1 1816 self.__post_evalutate_any_test_1 = __post_evalutate_any_test_1 1817 if not hasattr(self, '_post_any_code_evaluators'): 1818 self._post_any_code_evaluators = [] 1819 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1820 def _run_evaluators(event): 1821 _post_any_code_evaluators = self._post_any_code_evaluators 1822 if len(_post_any_code_evaluators) > 0: 1823 for id, evaluator in _post_any_code_evaluators: 1824 try: 1825 evaluator() 1826 except Exception, e: 1827 print "Exception while running Any Code evaluator for '%s':" % (id), e 1828 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1829 self._run_evaluators = _run_evaluators 1830 try: 1831 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1832 except: 1833 pass # FIXME 1834 def _run_evaluators_later(evaluator=None): 1835 if evaluator is not None: 1836 self._post_any_code_evaluators += [evaluator] 1837 try: 1838 de = wx.PyEvent() 1839 de.SetEventType(wxEVT_AnyCode) 1840 wx.PostEvent(self.GetWin(), de) 1841 except TypeError: 1842 pass 1843 except AttributeError: # FIXME 1844 print "Cannot post message" 1845 self._run_evaluators_later = _run_evaluators_later 1846 _run_evaluators_later() 1847 def __post_evalutate_actual_sample_rate(): 1848 self._post_any_code_evaluators += [('actual_sample_rate', lambda: self._evalutate_actual_sample_rate(**{'requested_sample_rate': requested_sample_rate}))] 1849 def __evalutate_actual_sample_rate(*args, **kwds): 1850 try: 1851 self.actual_sample_rate = self.src.get_samp_rate() 1852 self.set_actual_sample_rate(self.actual_sample_rate) 1853 except AttributeError, e: 1854 print "AttributeError while evaulating actual_sample_rate:", e 1855 __post_evalutate_actual_sample_rate() 1856 except Exception, e: 1857 print "Exception while evaluating actual_sample_rate:", e 1858 self._evalutate_actual_sample_rate = __evalutate_actual_sample_rate 1859 self.__post_evalutate_actual_sample_rate = __post_evalutate_actual_sample_rate 1860 self._evalutate_actual_sample_rate(**{'requested_sample_rate': requested_sample_rate}) 1861 actual_sample_rate = self.actual_sample_rate 1862 if not hasattr(self, '_post_any_code_evaluators'): 1863 self._post_any_code_evaluators = [] 1864 self.wxEVT_AnyCode = wxEVT_AnyCode = wx.NewEventType() 1865 def _run_evaluators(event): 1866 _post_any_code_evaluators = self._post_any_code_evaluators 1867 if len(_post_any_code_evaluators) > 0: 1868 for id, evaluator in _post_any_code_evaluators: 1869 try: 1870 evaluator() 1871 except Exception, e: 1872 print "Exception while running Any Code evaluator for '%s':" % (id), e 1873 del _post_any_code_evaluators[0:len(_post_any_code_evaluators)] 1874 self._run_evaluators = _run_evaluators 1875 try: 1876 self.GetWin().Connect(-1, -1, wxEVT_AnyCode, _run_evaluators) 1877 except: 1878 pass # FIXME 1879 def _run_evaluators_later(evaluator=None): 1880 if evaluator is not None: 1881 self._post_any_code_evaluators += [evaluator] 1882 try: 1883 de = wx.PyEvent() 1884 de.SetEventType(wxEVT_AnyCode) 1885 wx.PostEvent(self.GetWin(), de) 1886 except TypeError: 1887 pass 1888 except AttributeError: # FIXME 1889 print "Cannot post message" 1890 self._run_evaluators_later = _run_evaluators_later 1891 _run_evaluators_later() 1892 def __post_evalutate_actual_center_freq(): 1893 self._post_any_code_evaluators += [('actual_center_freq', lambda: self._evalutate_actual_center_freq(**{'tune_obj': tune_obj}))] 1894 def __evalutate_actual_center_freq(*args, **kwds): 1895 try: 1896 self.actual_center_freq = self.src.get_center_freq() 1897 self.set_actual_center_freq(self.actual_center_freq) 1898 except AttributeError, e: 1899 print "AttributeError while evaulating actual_center_freq:", e 1900 __post_evalutate_actual_center_freq() 1901 except Exception, e: 1902 print "Exception while evaluating actual_center_freq:", e 1903 self._evalutate_actual_center_freq = __evalutate_actual_center_freq 1904 self.__post_evalutate_actual_center_freq = __post_evalutate_actual_center_freq 1905 self._evalutate_actual_center_freq(**{'tune_obj': tune_obj}) 1906 actual_center_freq = self.actual_center_freq 1907 1908 ################################################## 1909 # Connections 1910 ################################################## 1911 self.connect((self.blks2_selector_0, 0), (self.wxgui_scopesink2_0, 0)) 1912 self.connect((self.blks2_selector_0_0, 0), (self.blks2_selector_0, 0)) 1913 self.connect((self.blks2_selector_0_0, 1), (self.blocks_complex_to_mag_0, 0)) 1914 self.connect((self.blks2_selector_0_0_0, 0), (self.blks2_selector_0_1, 0)) 1915 self.connect((self.blks2_selector_0_0_0, 1), (self.blocks_complex_to_mag_0_0, 0)) 1916 self.connect((self.blks2_selector_0_1, 0), (self.wxgui_scopesink2_0_0, 0)) 1917 self.connect((self.blocks_argmax_xx_0, 1), (self.blocks_null_sink_0, 0)) 1918 self.connect((self.blocks_argmax_xx_0, 0), (self.fft_max_idx_probe, 0)) 1919 self.connect((self.blocks_argmax_xx_0_0, 1), (self.blocks_null_sink_0_0, 0)) 1920 self.connect((self.blocks_argmax_xx_0_0, 0), (self.fft_max_idx_probe_0, 0)) 1921 self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_float_to_complex_0, 1)) 1922 self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_float_to_complex_0, 0)) 1923 self.connect((self.blocks_complex_to_mag_0_0, 0), (self.blocks_float_to_complex_0_0, 1)) 1924 self.connect((self.blocks_complex_to_mag_0_0, 0), (self.blocks_float_to_complex_0_0, 0)) 1925 self.connect((self.blocks_float_to_complex_0, 0), (self.blks2_selector_0, 1)) 1926 self.connect((self.blocks_float_to_complex_0_0, 0), (self.blks2_selector_0_1, 1)) 1927 self.connect((self.blocks_max_xx_0, 0), (self.fft_max_lvl_probe, 0)) 1928 self.connect((self.blocks_max_xx_0_0, 0), (self.fft_max_lvl_probe_2, 0)) 1929 self.connect((self.logpwrfft_x_0, 0), (self.blocks_argmax_xx_0, 0)) 1930 self.connect((self.logpwrfft_x_0, 0), (self.blocks_max_xx_0, 0)) 1931 self.connect((self.logpwrfft_x_0_0, 0), (self.blocks_argmax_xx_0_0, 0)) 1932 self.connect((self.logpwrfft_x_0_0, 0), (self.blocks_max_xx_0_0, 0)) 1933 self.connect((self.src, 0), (self.blocks_tag_debug_0, 0)) 1934 self.connect((self.src, 0), (self.blks2_selector_0_0, 0)) 1935 self.connect((self.src, 0), (self.fft_sink, 0)) 1936 self.connect((self.src, 0), (self.waterfall_sink, 0)) 1937 self.connect((self.src, 0), (self.probe_avg_mag, 0)) 1938 self.connect((self.src, 0), (self.logpwrfft_x_0, 0)) 1939 self.connect((self.src, 1), (self.blks2_selector_0_0_0, 0)) 1940 self.connect((self.src, 1), (self.fft_sink_two_1, 0)) 1941 self.connect((self.src, 1), (self.logpwrfft_x_0_0, 0)) 1942 self.connect((self.src, 1), (self.waterfall_sink_0, 0)) 1943 1944 1945 def get_antenna(self): 1946 return self.antenna 1947 1948 def set_antenna(self, antenna): 1949 self.antenna = antenna 1950 self.set_selected_antenna([ [self.antenna,self.antennas[0]][self.antenna not in self.antennas] ,self.antennas[0]][self.antenna=='']) 1951 1952 def get_args(self): 1953 return self.args 1954 1955 def set_args(self, args): 1956 self.args = args 1957 1958 def get_ave(self): 1959 return self.ave 1960 1961 def set_ave(self, ave): 1962 self.ave = ave 1963 self.set_fft_ave_probe(self.ave) 1964 1965 def get_averaging(self): 1966 return self.averaging 1967 1968 def set_averaging(self, averaging): 1969 self.averaging = averaging 1970 self.set_fft_averaging(self.str_to_bool(self.averaging)) 1971 1972 def get_bw(self): 1973 return self.bw 1974 1975 def set_bw(self, bw): 1976 self.bw = bw 1977 self.src.set_bandwidth(self.bw, 0) 1978 self.src.set_bandwidth(self.bw, 1) 1979 1980 def get_dyn_rng(self): 1981 return self.dyn_rng 1982 1983 def set_dyn_rng(self, dyn_rng): 1984 self.dyn_rng = dyn_rng 1985 1986 def get_fft_rate(self): 1987 return self.fft_rate 1988 1989 def set_fft_rate(self, fft_rate): 1990 self.fft_rate = fft_rate 1991 1992 def get_fft_ref_scale(self): 1993 return self.fft_ref_scale 1994 1995 def set_fft_ref_scale(self, fft_ref_scale): 1996 self.fft_ref_scale = fft_ref_scale 1997 1998 def get_fft_size(self): 1999 return self.fft_size 2000 2001 def set_fft_size(self, fft_size): 2002 self.fft_size = fft_size 2003 self.set_fft_max_idx((self.fft_size/2)*0) 2004 self.set_fft_max_idx_norm([self.fft_max_idx,self.fft_max_idx-self.fft_size][int(self.fft_max_idx>(self.fft_size/2))]) 2005 self.set_max_bin_freq(self.fft_center_freq + (((1.0*self.fft_max_idx_norm) / self.fft_size) * self.samp_rate)) 2006 2007 def get_freq(self): 2008 return self.freq 2009 2010 def set_freq(self, freq): 2011 self.freq = freq 2012 self.set_requested_freq_txt(self.freq) 2013 self.src.set_center_freq(uhd.tune_request(self.freq, self.lo_offset), 0) 2014 self.src.set_center_freq(uhd.tune_request(self.freq, self.lo_offset), 1) 2015 2016 def get_freq_fine_range(self): 2017 return self.freq_fine_range 2018 2019 def set_freq_fine_range(self, freq_fine_range): 2020 self.freq_fine_range = freq_fine_range 2021 2022 def get_gain(self): 2023 return self.gain 2024 2025 def set_gain(self, gain): 2026 self.gain = gain 2027 2028 def get_lo_check_interval(self): 2029 return self.lo_check_interval 2030 2031 def set_lo_check_interval(self, lo_check_interval): 2032 self.lo_check_interval = lo_check_interval 2033 self.set_locked_probe_poll_rate(self.lo_check_interval * float(self.has_lo_locked)) 2034 2035 def get_lo_offset(self): 2036 return self.lo_offset 2037 2038 def set_lo_offset(self, lo_offset): 2039 self.lo_offset = lo_offset 2040 self.set_lo_offset_txt(self.lo_offset) 2041 self.set_tune_mode([1,0][self.lo_offset==0.0]) 2042 self.src.set_center_freq(uhd.tune_request(self.freq, self.lo_offset), 0) 2043 self.src.set_center_freq(uhd.tune_request(self.freq, self.lo_offset), 1) 2044 2045 def get_mag_alpha(self): 2046 return self.mag_alpha 2047 2048 def set_mag_alpha(self, mag_alpha): 2049 self.mag_alpha = mag_alpha 2050 self.probe_avg_mag.set_alpha(self.mag_alpha) 2051 2052 def get_peak_hold(self): 2053 return self.peak_hold 2054 2055 def set_peak_hold(self, peak_hold): 2056 self.peak_hold = peak_hold 2057 self.set_fft_peak_hold(self.str_to_bool(self.peak_hold)) 2058 2059 def get_pps(self): 2060 return self.pps 2061 2062 def set_pps(self, pps): 2063 self.pps = pps 2064 self._evalutate_update_time_source(**{'pps': self.pps}) 2065 2066 def get_probe_interval(self): 2067 return self.probe_interval 2068 2069 def set_probe_interval(self, probe_interval): 2070 self.probe_interval = probe_interval 2071 self.set_fft_max_idx_poll_rate(self.probe_interval) 2072 self.set_fft_max_lvl_poll_rate(self.probe_interval) 2073 self.set_fft_max_lvl_2_poll_rate(self.probe_interval) 2074 self.set_signal_probe_poll_rate(self.probe_interval) 2075 2076 def get_rate(self): 2077 return self.rate 2078 2079 def set_rate(self, rate): 2080 self.rate = rate 2081 self.set_requested_sample_rate_base(self.rate) 2082 2083 def get_ref(self): 2084 return self.ref 2085 2086 def set_ref(self, ref): 2087 self.ref = ref 2088 self._evalutate_update_clock_source(**{'ref': self.ref}) 2089 2090 def get_ref_lvl(self): 2091 return self.ref_lvl 2092 2093 def set_ref_lvl(self, ref_lvl): 2094 self.ref_lvl = ref_lvl 2095 2096 def get_sensor_interval(self): 2097 return self.sensor_interval 2098 2099 def set_sensor_interval(self, sensor_interval): 2100 self.sensor_interval = sensor_interval 2101 self.set_daughterboard_sensor_names_poll_rate(self.sensor_interval) 2102 self.set_motherboard_sensor_names_poll_rate(self.sensor_interval) 2103 self.set_time_probe_poll_rate(self.sensor_interval) 2104 2105 def get_show_stream_tags(self): 2106 return self.show_stream_tags 2107 2108 def set_show_stream_tags(self, show_stream_tags): 2109 self.show_stream_tags = show_stream_tags 2110 self.set_show_stream_tags_chk([False, True][self.show_stream_tags.lower() != 'false']) 2111 2112 def get_spec(self): 2113 return self.spec 2114 2115 def set_spec(self, spec): 2116 self.spec = spec 2117 2118 def get_stream_args(self): 2119 return self.stream_args 2120 2121 def set_stream_args(self, stream_args): 2122 self.stream_args = stream_args 2123 2124 def get_window(self): 2125 return self.window 2126 2127 def set_window(self, window): 2128 self.window = window 2129 self.set_variable_static_fft_window_name(self.window_fn_name_map[self.window]) 2130 self.set_window_fn(self.window_fn_map[self.window]) 2131 2132 def get_wire_format(self): 2133 return self.wire_format 2134 2135 def set_wire_format(self, wire_format): 2136 self.wire_format = wire_format 2137 2138 def get_relative_freq(self): 2139 return self.relative_freq 2140 2141 def set_relative_freq(self, relative_freq): 2142 self.relative_freq = relative_freq 2143 self.set_fft_center_freq(self.actual_center_freq * self.relative_freq) 2144 self._relative_freq_chooser.set_value(self.relative_freq) 2145 2146 def get_gain_range(self): 2147 return self.gain_range 2148 2149 def set_gain_range(self, gain_range): 2150 self.gain_range = gain_range 2151 self._run_evaluators_later(('initial_gain', lambda: self._evalutate_initial_gain(**{'gain_range': self.gain_range}))) 2152 2153 def get_fft_max_idx(self): 2154 return self.fft_max_idx 2155 2156 def set_fft_max_idx(self, fft_max_idx): 2157 self.fft_max_idx = fft_max_idx 2158 self.set_fft_max_idx_norm([self.fft_max_idx,self.fft_max_idx-self.fft_size][int(self.fft_max_idx>(self.fft_size/2))]) 2159 2160 def get_actual_sample_rate(self): 2161 return self.actual_sample_rate 2162 2163 def set_actual_sample_rate(self, actual_sample_rate): 2164 self.actual_sample_rate = actual_sample_rate 2165 self.set_samp_rate(int(self.actual_sample_rate)) 2166 self.set_variable_static_actual_sample_rate(self.actual_sample_rate) 2167 2168 def get_actual_center_freq(self): 2169 return self.actual_center_freq 2170 2171 def set_actual_center_freq(self, actual_center_freq): 2172 self.actual_center_freq = actual_center_freq 2173 self.set_fft_center_freq(self.actual_center_freq * self.relative_freq) 2174 2175 def get_str_to_bool(self): 2176 return self.str_to_bool 2177 2178 def set_str_to_bool(self, str_to_bool): 2179 self.str_to_bool = str_to_bool 2180 self.set_fft_averaging(self.str_to_bool(self.averaging)) 2181 self.set_fft_peak_hold(self.str_to_bool(self.peak_hold)) 2182 2183 def get_signal_probe(self): 2184 return self.signal_probe 2185 2186 def set_signal_probe(self, signal_probe): 2187 self.signal_probe = signal_probe 2188 self.set_signal_probe_log(math.log10([self.signal_probe,1.0][self.signal_probe==0.0])*10) 2189 2190 def get_samp_rate(self): 2191 return self.samp_rate 2192 2193 def set_samp_rate(self, samp_rate): 2194 self.samp_rate = samp_rate 2195 self.set_max_bin_freq(self.fft_center_freq + (((1.0*self.fft_max_idx_norm) / self.fft_size) * self.samp_rate)) 2196 self.fft_sink.set_sample_rate(self.samp_rate) 2197 self.fft_sink_two_1.set_sample_rate(self.samp_rate) 2198 self.logpwrfft_x_0.set_sample_rate(self.samp_rate) 2199 self.logpwrfft_x_0_0.set_sample_rate(self.samp_rate) 2200 self.waterfall_sink.set_sample_rate(self.samp_rate) 2201 self.waterfall_sink_0.set_sample_rate(self.samp_rate) 2202 self.wxgui_scopesink2_0.set_sample_rate(self.samp_rate) 2203 self.wxgui_scopesink2_0_0.set_sample_rate(self.samp_rate) 2204 2205 def get_requested_freq_txt(self): 2206 return self.requested_freq_txt 2207 2208 def set_requested_freq_txt(self, requested_freq_txt): 2209 self.requested_freq_txt = requested_freq_txt 2210 self.set_requested_freq(self.requested_freq_txt + self.freq_fine) 2211 self._requested_freq_txt_slider.set_value(self.requested_freq_txt) 2212 self._requested_freq_txt_text_box.set_value(self.requested_freq_txt) 2213 2214 def get_gain_default(self): 2215 return self.gain_default 2216 2217 def set_gain_default(self, gain_default): 2218 self.gain_default = gain_default 2219 self.set_selected_gain(self.gain_default) 2220 2221 def get_freq_fine(self): 2222 return self.freq_fine 2223 2224 def set_freq_fine(self, freq_fine): 2225 self.freq_fine = freq_fine 2226 self._freq_fine_slider.set_value(self.freq_fine) 2227 self._freq_fine_text_box.set_value(self.freq_fine) 2228 self.set_requested_freq(self.requested_freq_txt + self.freq_fine) 2229 2230 def get_fft_max_idx_norm(self): 2231 return self.fft_max_idx_norm 2232 2233 def set_fft_max_idx_norm(self, fft_max_idx_norm): 2234 self.fft_max_idx_norm = fft_max_idx_norm 2235 self.set_max_bin_freq(self.fft_center_freq + (((1.0*self.fft_max_idx_norm) / self.fft_size) * self.samp_rate)) 2236 2237 def get_fft_center_freq(self): 2238 return self.fft_center_freq 2239 2240 def set_fft_center_freq(self, fft_center_freq): 2241 self.fft_center_freq = fft_center_freq 2242 self.set_max_bin_freq(self.fft_center_freq + (((1.0*self.fft_max_idx_norm) / self.fft_size) * self.samp_rate)) 2243 self.fft_sink.set_baseband_freq(self.fft_center_freq) 2244 self.fft_sink_two_1.set_baseband_freq(self.fft_center_freq) 2245 self.waterfall_sink.set_baseband_freq(self.fft_center_freq) 2246 self.waterfall_sink_0.set_baseband_freq(self.fft_center_freq) 2247 2248 def get_antennas(self): 2249 return self.antennas 2250 2251 def set_antennas(self, antennas): 2252 self.antennas = antennas 2253 self.set_selected_antenna([ [self.antenna,self.antennas[0]][self.antenna not in self.antennas] ,self.antennas[0]][self.antenna=='']) 2254 2255 def get_window_fn_name_map(self): 2256 return self.window_fn_name_map 2257 2258 def set_window_fn_name_map(self, window_fn_name_map): 2259 self.window_fn_name_map = window_fn_name_map 2260 self.set_variable_static_fft_window_name(self.window_fn_name_map[self.window]) 2261 2262 def get_window_fn_map(self): 2263 return self.window_fn_map 2264 2265 def set_window_fn_map(self, window_fn_map): 2266 self.window_fn_map = window_fn_map 2267 self.set_window_fn(self.window_fn_map[self.window]) 2268 2269 def get_usrp_info(self): 2270 return self.usrp_info 2271 2272 def set_usrp_info(self, usrp_info): 2273 self.usrp_info = usrp_info 2274 self.set_variable_static_usrp_info(self.usrp_info) 2275 2276 def get_tune_result(self): 2277 return self.tune_result 2278 2279 def set_tune_result(self, tune_result): 2280 self.tune_result = tune_result 2281 self.set_variable_static_actual_dsp_freq(self.tune_result.actual_dsp_freq) 2282 self.set_variable_static_rf_freq(self.tune_result.actual_rf_freq) 2283 2284 def get_tune_mode(self): 2285 return self.tune_mode 2286 2287 def set_tune_mode(self, tune_mode): 2288 self.tune_mode = tune_mode 2289 self._tune_mode_chooser.set_value(self.tune_mode) 2290 self.set_tune_obj([self.requested_freq, uhd.tune_request(self.requested_freq, self.lo_offset_txt), uhd.tune_request(self.requested_freq, dsp_freq=0, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)][self.tune_mode]) 2291 2292 def get_time_probe(self): 2293 return self.time_probe 2294 2295 def set_time_probe(self, time_probe): 2296 self.time_probe = time_probe 2297 self.set_variable_static_time_now(str( [time.ctime(self.time_probe.get_real_secs()), datetime.timedelta(seconds=self.time_probe.get_real_secs()), time.gmtime(self.time_probe.get_real_secs())] [self.relative_time])) 2298 2299 def get_test(self): 2300 return self.test 2301 2302 def set_test(self, test): 2303 self.test = test 2304 self._run_evaluators_later(('any_test_1', lambda: self._evalutate_any_test_1(**{'test': self.test}))) 2305 self._test_chooser.set_value(self.test) 2306 2307 def get_subdev_spec(self): 2308 return self.subdev_spec 2309 2310 def set_subdev_spec(self, subdev_spec): 2311 self.subdev_spec = subdev_spec 2312 self.set_variable_static_subdev_spec(self.subdev_spec) 2313 2314 def get_signal_probe_log(self): 2315 return self.signal_probe_log 2316 2317 def set_signal_probe_log(self, signal_probe_log): 2318 self.signal_probe_log = signal_probe_log 2319 self.set_variable_static_level_probe(self.signal_probe_log) 2320 2321 def get_selected_gain(self): 2322 return self.selected_gain 2323 2324 def set_selected_gain(self, selected_gain): 2325 self.selected_gain = selected_gain 2326 self._selected_gain_slider.set_value(self.selected_gain) 2327 self._selected_gain_text_box.set_value(self.selected_gain) 2328 self.set_selected_gain_proxy(self.selected_gain) 2329 2330 def get_selected_antenna(self): 2331 return self.selected_antenna 2332 2333 def set_selected_antenna(self, selected_antenna): 2334 self.selected_antenna = selected_antenna 2335 self._selected_antenna_chooser.set_value(self.selected_antenna) 2336 self.set_selected_antenna_proxy(self.selected_antenna) 2337 2338 def get_requested_sample_rate_base(self): 2339 return self.requested_sample_rate_base 2340 2341 def set_requested_sample_rate_base(self, requested_sample_rate_base): 2342 self.requested_sample_rate_base = requested_sample_rate_base 2343 self.set_requested_sample_rate(self.requested_sample_rate_base / (1.*self.decim)) 2344 self._requested_sample_rate_base_text_box.set_value(self.requested_sample_rate_base) 2345 2346 def get_requested_freq(self): 2347 return self.requested_freq 2348 2349 def set_requested_freq(self, requested_freq): 2350 self.requested_freq = requested_freq 2351 self.set_tune_obj([self.requested_freq, uhd.tune_request(self.requested_freq, self.lo_offset_txt), uhd.tune_request(self.requested_freq, dsp_freq=0, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)][self.tune_mode]) 2352 self.set_variable_static_requested_freq(self.requested_freq) 2353 2354 def get_relative_time(self): 2355 return self.relative_time 2356 2357 def set_relative_time(self, relative_time): 2358 self.relative_time = relative_time 2359 self._relative_time_chooser.set_value(self.relative_time) 2360 self.set_variable_static_time_now(str( [time.ctime(self.time_probe.get_real_secs()), datetime.timedelta(seconds=self.time_probe.get_real_secs()), time.gmtime(self.time_probe.get_real_secs())] [self.relative_time])) 2361 2362 def get_motherboard_sensors(self): 2363 return self.motherboard_sensors 2364 2365 def set_motherboard_sensors(self, motherboard_sensors): 2366 self.motherboard_sensors = motherboard_sensors 2367 self.set_variable_static_text_0(self.motherboard_sensors) 2368 2369 def get_max_bin_freq(self): 2370 return self.max_bin_freq 2371 2372 def set_max_bin_freq(self, max_bin_freq): 2373 self.max_bin_freq = max_bin_freq 2374 self.set_variable_static_max_bin_freq(self.max_bin_freq) 2375 2376 def get_locked_probe(self): 2377 return self.locked_probe 2378 2379 def set_locked_probe(self, locked_probe): 2380 self.locked_probe = locked_probe 2381 self.set_static_locked('"' + str(self.locked_probe) + '"') 2382 2383 def get_lo_offset_txt(self): 2384 return self.lo_offset_txt 2385 2386 def set_lo_offset_txt(self, lo_offset_txt): 2387 self.lo_offset_txt = lo_offset_txt 2388 self._lo_offset_txt_text_box.set_value(self.lo_offset_txt) 2389 self.set_tune_obj([self.requested_freq, uhd.tune_request(self.requested_freq, self.lo_offset_txt), uhd.tune_request(self.requested_freq, dsp_freq=0, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL)][self.tune_mode]) 2390 2391 def get_fft_peak_hold(self): 2392 return self.fft_peak_hold 2393 2394 def set_fft_peak_hold(self, fft_peak_hold): 2395 self.fft_peak_hold = fft_peak_hold 2396 self._run_evaluators_later(('variable_any_code_fft_sink_peak_hold', lambda: self._evalutate_variable_any_code_fft_sink_peak_hold(**{'peak_hold': self.fft_peak_hold}))) 2397 2398 def get_fft_max_lvl_2(self): 2399 return self.fft_max_lvl_2 2400 2401 def set_fft_max_lvl_2(self, fft_max_lvl_2): 2402 self.fft_max_lvl_2 = fft_max_lvl_2 2403 self.set_fft_max_lvl_value_2(self.fft_max_lvl_2) 2404 2405 def get_fft_max_lvl(self): 2406 return self.fft_max_lvl 2407 2408 def set_fft_max_lvl(self, fft_max_lvl): 2409 self.fft_max_lvl = fft_max_lvl 2410 self.set_fft_max_lvl_value(self.fft_max_lvl) 2411 self.set_variable_static_fft_max_lvl_log(self.fft_max_lvl) 2412 2413 def get_fft_averaging(self): 2414 return self.fft_averaging 2415 2416 def set_fft_averaging(self, fft_averaging): 2417 self.fft_averaging = fft_averaging 2418 self._run_evaluators_later(('variable_any_code_fft_sink_ave', lambda: self._evalutate_variable_any_code_fft_sink_ave(**{'averaging': self.fft_averaging}))) 2419 self._run_evaluators_later(('variable_any_code_waterfall_ave', lambda: self._evalutate_variable_any_code_waterfall_ave(**{'averaging': self.fft_averaging}))) 2420 2421 def get_decim(self): 2422 return self.decim 2423 2424 def set_decim(self, decim): 2425 self.decim = decim 2426 self._decim_slider.set_value(self.decim) 2427 self._decim_text_box.set_value(self.decim) 2428 self.set_requested_sample_rate(self.requested_sample_rate_base / (1.*self.decim)) 2429 2430 def get_daughterboard_sensors(self): 2431 return self.daughterboard_sensors 2432 2433 def set_daughterboard_sensors(self, daughterboard_sensors): 2434 self.daughterboard_sensors = daughterboard_sensors 2435 self.set_variable_static_text_0_0(self.daughterboard_sensors) 2436 2437 def get_clicked_freq(self): 2438 return self.clicked_freq 2439 2440 def set_clicked_freq(self, clicked_freq): 2441 self.clicked_freq = clicked_freq 2442 self.set_clicked_freq_txt(self.clicked_freq) 2443 2444 def get_window_fn(self): 2445 return self.window_fn 2446 2447 def set_window_fn(self, window_fn): 2448 self.window_fn = window_fn 2449 2450 def get_variable_static_usrp_info(self): 2451 return self.variable_static_usrp_info 2452 2453 def set_variable_static_usrp_info(self, variable_static_usrp_info): 2454 self.variable_static_usrp_info = variable_static_usrp_info 2455 self._variable_static_usrp_info_static_text.set_value(self.variable_static_usrp_info) 2456 2457 def get_variable_static_time_now(self): 2458 return self.variable_static_time_now 2459 2460 def set_variable_static_time_now(self, variable_static_time_now): 2461 self.variable_static_time_now = variable_static_time_now 2462 self._variable_static_time_now_static_text.set_value(self.variable_static_time_now) 2463 2464 def get_variable_static_text_0_0(self): 2465 return self.variable_static_text_0_0 2466 2467 def set_variable_static_text_0_0(self, variable_static_text_0_0): 2468 self.variable_static_text_0_0 = variable_static_text_0_0 2469 self._variable_static_text_0_0_static_text.set_value(self.variable_static_text_0_0) 2470 2471 def get_variable_static_text_0(self): 2472 return self.variable_static_text_0 2473 2474 def set_variable_static_text_0(self, variable_static_text_0): 2475 self.variable_static_text_0 = variable_static_text_0 2476 self._variable_static_text_0_static_text.set_value(self.variable_static_text_0) 2477 2478 def get_variable_static_subdev_spec(self): 2479 return self.variable_static_subdev_spec 2480 2481 def set_variable_static_subdev_spec(self, variable_static_subdev_spec): 2482 self.variable_static_subdev_spec = variable_static_subdev_spec 2483 self._variable_static_subdev_spec_static_text.set_value(self.variable_static_subdev_spec) 2484 2485 def get_variable_static_rf_freq(self): 2486 return self.variable_static_rf_freq 2487 2488 def set_variable_static_rf_freq(self, variable_static_rf_freq): 2489 self.variable_static_rf_freq = variable_static_rf_freq 2490 self._variable_static_rf_freq_static_text.set_value(self.variable_static_rf_freq) 2491 2492 def get_variable_static_requested_freq(self): 2493 return self.variable_static_requested_freq 2494 2495 def set_variable_static_requested_freq(self, variable_static_requested_freq): 2496 self.variable_static_requested_freq = variable_static_requested_freq 2497 self._variable_static_requested_freq_static_text.set_value(self.variable_static_requested_freq) 2498 2499 def get_variable_static_max_bin_freq(self): 2500 return self.variable_static_max_bin_freq 2501 2502 def set_variable_static_max_bin_freq(self, variable_static_max_bin_freq): 2503 self.variable_static_max_bin_freq = variable_static_max_bin_freq 2504 self._variable_static_max_bin_freq_static_text.set_value(self.variable_static_max_bin_freq) 2505 2506 def get_variable_static_level_probe(self): 2507 return self.variable_static_level_probe 2508 2509 def set_variable_static_level_probe(self, variable_static_level_probe): 2510 self.variable_static_level_probe = variable_static_level_probe 2511 self._variable_static_level_probe_static_text.set_value(self.variable_static_level_probe) 2512 2513 def get_variable_static_fft_window_name(self): 2514 return self.variable_static_fft_window_name 2515 2516 def set_variable_static_fft_window_name(self, variable_static_fft_window_name): 2517 self.variable_static_fft_window_name = variable_static_fft_window_name 2518 self._variable_static_fft_window_name_static_text.set_value(self.variable_static_fft_window_name) 2519 2520 def get_variable_static_fft_max_lvl_log(self): 2521 return self.variable_static_fft_max_lvl_log 2522 2523 def set_variable_static_fft_max_lvl_log(self, variable_static_fft_max_lvl_log): 2524 self.variable_static_fft_max_lvl_log = variable_static_fft_max_lvl_log 2525 self._variable_static_fft_max_lvl_log_static_text.set_value(self.variable_static_fft_max_lvl_log) 2526 2527 def get_variable_static_actual_sample_rate(self): 2528 return self.variable_static_actual_sample_rate 2529 2530 def set_variable_static_actual_sample_rate(self, variable_static_actual_sample_rate): 2531 self.variable_static_actual_sample_rate = variable_static_actual_sample_rate 2532 self._variable_static_actual_sample_rate_static_text.set_value(self.variable_static_actual_sample_rate) 2533 2534 def get_variable_static_actual_dsp_freq(self): 2535 return self.variable_static_actual_dsp_freq 2536 2537 def set_variable_static_actual_dsp_freq(self, variable_static_actual_dsp_freq): 2538 self.variable_static_actual_dsp_freq = variable_static_actual_dsp_freq 2539 self._variable_static_actual_dsp_freq_static_text.set_value(self.variable_static_actual_dsp_freq) 2540 2541 def get_variable_any_code_waterfall_ave(self): 2542 return self.variable_any_code_waterfall_ave 2543 2544 def set_variable_any_code_waterfall_ave(self, variable_any_code_waterfall_ave): 2545 self.variable_any_code_waterfall_ave = variable_any_code_waterfall_ave 2546 2547 def get_variable_any_code_iq_correction(self): 2548 return self.variable_any_code_iq_correction 2549 2550 def set_variable_any_code_iq_correction(self, variable_any_code_iq_correction): 2551 self.variable_any_code_iq_correction = variable_any_code_iq_correction 2552 2553 def get_variable_any_code_fft_sink_peak_hold(self): 2554 return self.variable_any_code_fft_sink_peak_hold 2555 2556 def set_variable_any_code_fft_sink_peak_hold(self, variable_any_code_fft_sink_peak_hold): 2557 self.variable_any_code_fft_sink_peak_hold = variable_any_code_fft_sink_peak_hold 2558 2559 def get_variable_any_code_fft_sink_ave(self): 2560 return self.variable_any_code_fft_sink_ave 2561 2562 def set_variable_any_code_fft_sink_ave(self, variable_any_code_fft_sink_ave): 2563 self.variable_any_code_fft_sink_ave = variable_any_code_fft_sink_ave 2564 2565 def get_variable_any_code_auto_dc_offset_removal(self): 2566 return self.variable_any_code_auto_dc_offset_removal 2567 2568 def set_variable_any_code_auto_dc_offset_removal(self, variable_any_code_auto_dc_offset_removal): 2569 self.variable_any_code_auto_dc_offset_removal = variable_any_code_auto_dc_offset_removal 2570 2571 def get_update_time_source(self): 2572 return self.update_time_source 2573 2574 def set_update_time_source(self, update_time_source): 2575 self.update_time_source = update_time_source 2576 2577 def get_update_clock_source(self): 2578 return self.update_clock_source 2579 2580 def set_update_clock_source(self, update_clock_source): 2581 self.update_clock_source = update_clock_source 2582 2583 def get_tune_obj(self): 2584 return self.tune_obj 2585 2586 def set_tune_obj(self, tune_obj): 2587 self.tune_obj = tune_obj 2588 self._run_evaluators_later(('actual_center_freq', lambda: self._evalutate_actual_center_freq(**{'tune_obj': self.tune_obj}))) 2589 self._run_evaluators_later(('tune_result', lambda: self._evalutate_tune_result(**{'tune_obj': self.tune_obj}))) 2590 2591 def get_static_locked(self): 2592 return self.static_locked 2593 2594 def set_static_locked(self, static_locked): 2595 self.static_locked = static_locked 2596 self._static_locked_static_text.set_value(self.static_locked) 2597 2598 def get_show_stream_tags_chk(self): 2599 return self.show_stream_tags_chk 2600 2601 def set_show_stream_tags_chk(self, show_stream_tags_chk): 2602 self.show_stream_tags_chk = show_stream_tags_chk 2603 self._show_stream_tags_chk_check_box.set_value(self.show_stream_tags_chk) 2604 self.blocks_tag_debug_0.set_display(self.show_stream_tags_chk) 2605 2606 def get_show_max_lvl(self): 2607 return self.show_max_lvl 2608 2609 def set_show_max_lvl(self, show_max_lvl): 2610 self.show_max_lvl = show_max_lvl 2611 self._show_max_lvl_check_box.set_value(self.show_max_lvl) 2612 2613 def get_show_max_freq(self): 2614 return self.show_max_freq 2615 2616 def set_show_max_freq(self, show_max_freq): 2617 self.show_max_freq = show_max_freq 2618 self._show_max_freq_check_box.set_value(self.show_max_freq) 2619 2620 def get_selected_gain_proxy(self): 2621 return self.selected_gain_proxy 2622 2623 def set_selected_gain_proxy(self, selected_gain_proxy): 2624 self.selected_gain_proxy = selected_gain_proxy 2625 self.src.set_gain(self.selected_gain_proxy, 0) 2626 self.src.set_gain(self.selected_gain_proxy, 1) 2627 2628 def get_selected_antenna_proxy(self): 2629 return self.selected_antenna_proxy 2630 2631 def set_selected_antenna_proxy(self, selected_antenna_proxy): 2632 self.selected_antenna_proxy = selected_antenna_proxy 2633 self.src.set_antenna(self.selected_antenna_proxy, 0) 2634 self.src.set_antenna(self.selected_antenna_proxy, 1) 2635 2636 def get_scope_mode_2(self): 2637 return self.scope_mode_2 2638 2639 def set_scope_mode_2(self, scope_mode_2): 2640 self.scope_mode_2 = scope_mode_2 2641 self._scope_mode_2_chooser.set_value(self.scope_mode_2) 2642 self.blks2_selector_0_0_0.set_output_index(int(self.scope_mode_2)) 2643 self.blks2_selector_0_1.set_input_index(int(self.scope_mode_2)) 2644 2645 def get_scope_mode(self): 2646 return self.scope_mode 2647 2648 def set_scope_mode(self, scope_mode): 2649 self.scope_mode = scope_mode 2650 self._scope_mode_chooser.set_value(self.scope_mode) 2651 self.blks2_selector_0.set_input_index(int(self.scope_mode)) 2652 self.blks2_selector_0_0.set_output_index(int(self.scope_mode)) 2653 2654 def get_requested_sample_rate(self): 2655 return self.requested_sample_rate 2656 2657 def set_requested_sample_rate(self, requested_sample_rate): 2658 self.requested_sample_rate = requested_sample_rate 2659 self._run_evaluators_later(('actual_sample_rate', lambda: self._evalutate_actual_sample_rate(**{'requested_sample_rate': self.requested_sample_rate}))) 2660 self.src.set_samp_rate(self.requested_sample_rate) 2661 2662 def get_motherboard_sensor_names(self): 2663 return self.motherboard_sensor_names 2664 2665 def set_motherboard_sensor_names(self, motherboard_sensor_names): 2666 self.motherboard_sensor_names = motherboard_sensor_names 2667 self._run_evaluators_later(('motherboard_sensors', lambda: self._evalutate_motherboard_sensors(**{'motherboard_sensor_names': self.motherboard_sensor_names}))) 2668 2669 def get_max_decim(self): 2670 return self.max_decim 2671 2672 def set_max_decim(self, max_decim): 2673 self.max_decim = max_decim 2674 2675 def get_initial_gain(self): 2676 return self.initial_gain 2677 2678 def set_initial_gain(self, initial_gain): 2679 self.initial_gain = initial_gain 2680 self._run_evaluators_later(('gain_default', lambda: self._evalutate_gain_default(**{'initial_gain': self.initial_gain}))) 2681 2682 def get_has_lo_locked(self): 2683 return self.has_lo_locked 2684 2685 def set_has_lo_locked(self, has_lo_locked): 2686 self.has_lo_locked = has_lo_locked 2687 self.set_locked_probe_poll_rate(self.lo_check_interval * float(self.has_lo_locked)) 2688 2689 def get_freq_range(self): 2690 return self.freq_range 2691 2692 def set_freq_range(self, freq_range): 2693 self.freq_range = freq_range 2694 2695 def get_fix_invalid_freq(self): 2696 return self.fix_invalid_freq 2697 2698 def set_fix_invalid_freq(self, fix_invalid_freq): 2699 self.fix_invalid_freq = fix_invalid_freq 2700 2701 def get_fft_max_lvl_value_2(self): 2702 return self.fft_max_lvl_value_2 2703 2704 def set_fft_max_lvl_value_2(self, fft_max_lvl_value_2): 2705 self.fft_max_lvl_value_2 = fft_max_lvl_value_2 2706 2707 def get_fft_max_lvl_value(self): 2708 return self.fft_max_lvl_value 2709 2710 def set_fft_max_lvl_value(self, fft_max_lvl_value): 2711 self.fft_max_lvl_value = fft_max_lvl_value 2712 2713 def get_fft_ave_probe(self): 2714 return self.fft_ave_probe 2715 2716 def set_fft_ave_probe(self, fft_ave_probe): 2717 self.fft_ave_probe = fft_ave_probe 2718 self.logpwrfft_x_0.set_avg_alpha(self.fft_ave_probe) 2719 self.logpwrfft_x_0_0.set_avg_alpha(self.fft_ave_probe) 2720 2721 def get_daughterboard_sensor_names(self): 2722 return self.daughterboard_sensor_names 2723 2724 def set_daughterboard_sensor_names(self, daughterboard_sensor_names): 2725 self.daughterboard_sensor_names = daughterboard_sensor_names 2726 self._run_evaluators_later(('daughterboard_sensors', lambda: self._evalutate_daughterboard_sensors(**{'daughterboard_sensor_names': self.daughterboard_sensor_names}))) 2727 2728 def get_clicked_freq_txt(self): 2729 return self.clicked_freq_txt 2730 2731 def set_clicked_freq_txt(self, clicked_freq_txt): 2732 self.clicked_freq_txt = clicked_freq_txt 2733 self._clicked_freq_txt_text_box.set_value(self.clicked_freq_txt) 2734 2735 def get_auto_iq_correction(self): 2736 return self.auto_iq_correction 2737 2738 def set_auto_iq_correction(self, auto_iq_correction): 2739 self.auto_iq_correction = auto_iq_correction 2740 self._auto_iq_correction_check_box.set_value(self.auto_iq_correction) 2741 self._run_evaluators_later(('variable_any_code_iq_correction', lambda: self._evalutate_variable_any_code_iq_correction(**{'auto_iq_correction': self.auto_iq_correction}))) 2742 2743 def get_auto_dc_offset_removal(self): 2744 return self.auto_dc_offset_removal 2745 2746 def set_auto_dc_offset_removal(self, auto_dc_offset_removal): 2747 self.auto_dc_offset_removal = auto_dc_offset_removal 2748 self._auto_dc_offset_removal_check_box.set_value(self.auto_dc_offset_removal) 2749 self._run_evaluators_later(('variable_any_code_auto_dc_offset_removal', lambda: self._evalutate_variable_any_code_auto_dc_offset_removal(**{'auto_dc_offset_removal': self.auto_dc_offset_removal}))) 2750 2751 def get_any_test_1(self): 2752 return self.any_test_1 2753 2754 def set_any_test_1(self, any_test_1): 2755 self.any_test_1 = any_test_1 2756 2757 2758if __name__ == '__main__': 2759 parser = OptionParser(option_class=eng_option, usage="%prog: [options]") 2760 parser.add_option("-A", "--antenna", dest="antenna", type="string", default="", 2761 help="Set Antenna (blank for default) [default=%default]") 2762 parser.add_option("-a", "--args", dest="args", type="string", default="", 2763 help="Set UHD device args [default=%default]") 2764 parser.add_option("", "--ave", dest="ave", type="eng_float", default=eng_notation.num_to_str(1*0 + 0.5), 2765 help="Set Average FFT [default=%default]") 2766 parser.add_option("", "--averaging", dest="averaging", type="string", default="True", 2767 help="Set Enable FFT averaging [default=%default]") 2768 parser.add_option("", "--bw", dest="bw", type="eng_float", default=eng_notation.num_to_str(0), 2769 help="Set Daughterboard bandwidth (where appropriate) [default=%default]") 2770 parser.add_option("", "--dyn-rng", dest="dyn_rng", type="eng_float", default=eng_notation.num_to_str(130), 2771 help="Set Dynamic Range [default=%default]") 2772 parser.add_option("", "--fft-rate", dest="fft_rate", type="intx", default=15, 2773 help="Set FFT Rate [default=%default]") 2774 parser.add_option("", "--fft-ref-scale", dest="fft_ref_scale", type="eng_float", default=eng_notation.num_to_str(2.0), 2775 help="Set FFT Ref Scale (p2p) [default=%default]") 2776 parser.add_option("", "--fft-size", dest="fft_size", type="intx", default=1024, 2777 help="Set FFT Size [default=%default]") 2778 parser.add_option("-f", "--freq", dest="freq", type="eng_float", default=eng_notation.num_to_str(0 + 100e6), 2779 help="Set Frequency [default=%default]") 2780 parser.add_option("", "--freq-fine-range", dest="freq_fine_range", type="eng_float", default=eng_notation.num_to_str(2e6), 2781 help="Set Fine frequency slider range [default=%default]") 2782 parser.add_option("-g", "--gain", dest="gain", type="eng_float", default=eng_notation.num_to_str(float("-inf")), 2783 help="Set Gain (default '-inf' selects relative gain of 25%) [default=%default]") 2784 parser.add_option("", "--lo-check-interval", dest="lo_check_interval", type="eng_float", default=eng_notation.num_to_str(5), 2785 help="Set LO lock check frequency (Hz) [default=%default]") 2786 parser.add_option("", "--lo-offset", dest="lo_offset", type="eng_float", default=eng_notation.num_to_str(0), 2787 help="Set LO offset (selects LO offset tuning mode) [default=%default]") 2788 parser.add_option("", "--mag-alpha", dest="mag_alpha", type="eng_float", default=eng_notation.num_to_str(1e-3), 2789 help="Set Signal magnitude probe alpha [default=%default]") 2790 parser.add_option("", "--peak-hold", dest="peak_hold", type="string", default="False", 2791 help="Set FFT peak hold [default=%default]") 2792 parser.add_option("", "--pps", dest="pps", type="string", default='', 2793 help="Set Time source (none, internal, external, mimo, gpsdo). <empty> leaves it at the default. [default=%default]") 2794 parser.add_option("", "--probe-interval", dest="probe_interval", type="eng_float", default=eng_notation.num_to_str(3), 2795 help="Set Signal probe frequency (Hz) [default=%default]") 2796 parser.add_option("-s", "--rate", dest="rate", type="eng_float", default=eng_notation.num_to_str(1e6), 2797 help="Set Sample Rate [default=%default]") 2798 parser.add_option("", "--ref", dest="ref", type="string", default='', 2799 help="Set Clock source (internal, external, mimo, gpsdo). <empty> leaves it at the default. [default=%default]") 2800 parser.add_option("", "--ref-lvl", dest="ref_lvl", type="eng_float", default=eng_notation.num_to_str(0), 2801 help="Set Reference Level [default=%default]") 2802 parser.add_option("", "--sensor-interval", dest="sensor_interval", type="eng_float", default=eng_notation.num_to_str(2), 2803 help="Set Sensor update frequency (Hz) [default=%default]") 2804 parser.add_option("", "--show-stream-tags", dest="show_stream_tags", type="string", default="False", 2805 help="Set Print stream tags [default=%default]") 2806 parser.add_option("", "--spec", dest="spec", type="string", default='', 2807 help="Set Sub-device specification (where appropriate) [default=%default]") 2808 parser.add_option("", "--stream-args", dest="stream_args", type="string", default="", 2809 help="Set Stream arguments (e.g. scalar=1024) [default=%default]") 2810 parser.add_option("", "--window", dest="window", type="string", default="auto", 2811 help="Set Window (bh: Blackman-Harris, ham: Hamming, han: Hanning, rect: Rectangular, flat: Flattop) [default=%default]") 2812 parser.add_option("", "--wire-format", dest="wire_format", type="string", default="", 2813 help="Set Wire format (e.g. sc16, sc8) [blank = automatic] [default=%default]") 2814 (options, args) = parser.parse_args() 2815 if gr.enable_realtime_scheduling() != gr.RT_OK: 2816 print "Error: failed to enable realtime scheduling." 2817 tb = mega_fft_2ch(antenna=options.antenna, args=options.args, ave=options.ave, averaging=options.averaging, bw=options.bw, dyn_rng=options.dyn_rng, fft_rate=options.fft_rate, fft_ref_scale=options.fft_ref_scale, fft_size=options.fft_size, freq=options.freq, freq_fine_range=options.freq_fine_range, gain=options.gain, lo_check_interval=options.lo_check_interval, lo_offset=options.lo_offset, mag_alpha=options.mag_alpha, peak_hold=options.peak_hold, pps=options.pps, probe_interval=options.probe_interval, rate=options.rate, ref=options.ref, ref_lvl=options.ref_lvl, sensor_interval=options.sensor_interval, show_stream_tags=options.show_stream_tags, spec=options.spec, stream_args=options.stream_args, window=options.window, wire_format=options.wire_format) 2818 tb.Start(True) 2819 tb.Wait() 2820