git.gag.com Git - debian/gnuradio/blob - gr-wxgui/src/python/scopesink_nongl.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2003,2004,2006,2007 Free Software Foundation, Inc.
   4 #
   5 # This file is part of GNU Radio
   6 #
   7 # GNU Radio is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3, or (at your option)
  10 # any later version.
  11 #
  12 # GNU Radio is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with GNU Radio; see the file COPYING.  If not, write to
  19 # the Free Software Foundation, Inc., 51 Franklin Street,
  20 # Boston, MA 02110-1301, USA.
  21 #
  22
  23 from gnuradio import gr, gru, eng_notation
  24 from gnuradio.wxgui import stdgui2
  25 import wx
  26 import gnuradio.wxgui.plot as plot
  27 import numpy
  28 import threading
  29 import struct
  30
  31 default_scopesink_size = (640, 240)
  32 default_v_scale = 1000
  33 default_frame_decim = gr.prefs().get_long('wxgui', 'frame_decim', 1)
  34
  35 class scope_sink_f(gr.hier_block2):
  36     def __init__(self, parent, title='', sample_rate=1,
  37                  size=default_scopesink_size, frame_decim=default_frame_decim,
  38                  v_scale=default_v_scale, t_scale=None, num_inputs=1, **kwargs):
  39
  40         gr.hier_block2.__init__(self, "scope_sink_f",
  41                                 gr.io_signature(num_inputs, num_inputs, gr.sizeof_float),
  42                                 gr.io_signature(0,0,0))
  43
  44         msgq = gr.msg_queue(2)         # message queue that holds at most 2 messages
  45         self.guts = gr.oscope_sink_f(sample_rate, msgq)
  46         for i in range(num_inputs):
  47           self.connect((self, i), (self.guts, i))
  48
  49         self.win = scope_window(win_info (msgq, sample_rate, frame_decim,
  50                                           v_scale, t_scale, self.guts, title), parent)
  51
  52     def set_sample_rate(self, sample_rate):
  53         self.guts.set_sample_rate(sample_rate)
  54         self.win.info.set_sample_rate(sample_rate)
  55
  56 class scope_sink_c(gr.hier_block2):
  57     def __init__(self, parent, title='', sample_rate=1,
  58                  size=default_scopesink_size, frame_decim=default_frame_decim,
  59                  v_scale=default_v_scale, t_scale=None, num_inputs=1, **kwargs):
  60
  61         gr.hier_block2.__init__(self, "scope_sink_c",
  62                                 gr.io_signature(num_inputs, num_inputs, gr.sizeof_gr_complex),
  63                                 gr.io_signature(0,0,0))
  64
  65         msgq = gr.msg_queue(2)         # message queue that holds at most 2 messages
  66         self.guts = gr.oscope_sink_f(sample_rate, msgq)
  67         for i in range(num_inputs):
  68                 c2f = gr.complex_to_float()
  69                 self.connect((self, i), c2f)
  70                 self.connect((c2f, 0), (self.guts, 2*i+0))
  71                 self.connect((c2f, 1), (self.guts, 2*i+1))
  72
  73         self.win = scope_window(win_info(msgq, sample_rate, frame_decim,
  74                                          v_scale, t_scale, self.guts, title), parent)
  75
  76     def set_sample_rate(self, sample_rate):
  77         self.guts.set_sample_rate(sample_rate)
  78         self.win.info.set_sample_rate(sample_rate)
  79
  80 class constellation_sink(scope_sink_c):
  81     def __init__(self, parent, title='Constellation', sample_rate=1,
  82                  size=default_scopesink_size, frame_decim=default_frame_decim):
  83         scope_sink_c.__init__(self, parent=parent, title=title, sample_rate=sample_rate,
  84                  size=size, frame_decim=frame_decim)
  85         self.win.info.xy = True #constellation mode
  86
  87 # ========================================================================
  88
  89
  90 time_base_list = [                      # time / division
  91     1.0e-7,   # 100ns / div
  92     2.5e-7,
  93     5.0e-7,
  94     1.0e-6,   #   1us / div
  95     2.5e-6,
  96     5.0e-6,
  97     1.0e-5,   #  10us / div
  98     2.5e-5,
  99     5.0e-5,
 100     1.0e-4,   # 100us / div
 101     2.5e-4,
 102     5.0e-4,
 103     1.0e-3,   #   1ms / div
 104     2.5e-3,
 105     5.0e-3,
 106     1.0e-2,   #  10ms / div
 107     2.5e-2,
 108     5.0e-2
 109     ]
 110
 111 v_scale_list = [ # counts / div, LARGER gains are SMALLER /div, appear EARLIER
 112     2.0e-3,   # 2m / div, don't call it V/div it's actually counts/div
 113     5.0e-3,
 114     1.0e-2,
 115     2.0e-2,
 116     5.0e-2,
 117     1.0e-1,
 118     2.0e-1,
 119     5.0e-1,
 120     1.0e+0,
 121     2.0e+0,
 122     5.0e+0,
 123     1.0e+1,
 124     2.0e+1,
 125     5.0e+1,
 126     1.0e+2,
 127     2.0e+2,
 128     5.0e+2,
 129     1.0e+3,
 130     2.0e+3,
 131     5.0e+3,
 132     1.0e+4 # 10000 /div, USRP full scale is -/+ 32767
 133     ]
 134
 135
 136 wxDATA_EVENT = wx.NewEventType()
 137
 138 def EVT_DATA_EVENT(win, func):
 139     win.Connect(-1, -1, wxDATA_EVENT, func)
 140
 141 class DataEvent(wx.PyEvent):
 142     def __init__(self, data):
 143         wx.PyEvent.__init__(self)
 144         self.SetEventType (wxDATA_EVENT)
 145         self.data = data
 146
 147     def Clone (self):
 148         self.__class__ (self.GetId())
 149
 150
 151 class win_info (object):
 152     __slots__ = ['msgq', 'sample_rate', 'frame_decim', 'v_scale',
 153                  'scopesink', 'title',
 154                  'time_scale_cursor', 'v_scale_cursor', 'marker', 'xy',
 155                  'autorange', 'running']
 156
 157     def __init__ (self, msgq, sample_rate, frame_decim, v_scale, t_scale,
 158                   scopesink, title = "Oscilloscope", xy=False):
 159         self.msgq = msgq
 160         self.sample_rate = sample_rate
 161         self.frame_decim = frame_decim
 162         self.scopesink = scopesink
 163         self.title = title;
 164
 165         self.time_scale_cursor = gru.seq_with_cursor(time_base_list, initial_value = t_scale)
 166         self.v_scale_cursor = gru.seq_with_cursor(v_scale_list, initial_value = v_scale)
 167
 168         self.marker = 'line'
 169         self.xy = xy
 170         self.autorange = not v_scale
 171         self.running = True
 172
 173     def get_time_per_div (self):
 174         return self.time_scale_cursor.current ()
 175
 176     def get_volts_per_div (self):
 177         return self.v_scale_cursor.current ()
 178
 179     def set_sample_rate(self, sample_rate):
 180         self.sample_rate = sample_rate
 181
 182     def get_sample_rate (self):
 183         return self.sample_rate
 184
 185     def get_decimation_rate (self):
 186         return 1.0
 187
 188     def set_marker (self, s):
 189         self.marker = s
 190
 191     def get_marker (self):
 192         return self.marker
 193
 194
 195 class input_watcher (threading.Thread):
 196     def __init__ (self, msgq, event_receiver, frame_decim, **kwds):
 197         threading.Thread.__init__ (self, **kwds)
 198         self.setDaemon (1)
 199         self.msgq = msgq
 200         self.event_receiver = event_receiver
 201         self.frame_decim = frame_decim
 202         self.iscan = 0
 203         self.keep_running = True
 204         self.start ()
 205
 206     def run (self):
 207         # print "input_watcher: pid = ", os.getpid ()
 208         while (self.keep_running):
 209             msg = self.msgq.delete_head()   # blocking read of message queue
 210             if self.iscan == 0:            # only display at frame_decim
 211                 self.iscan = self.frame_decim
 212
 213                 nchan = int(msg.arg1())    # number of channels of data in msg
 214                 nsamples = int(msg.arg2()) # number of samples in each channel
 215
 216                 s = msg.to_string()      # get the body of the msg as a string
 217
 218                 bytes_per_chan = nsamples * gr.sizeof_float
 219
 220                 records = []
 221                 for ch in range (nchan):
 222
 223                     start = ch * bytes_per_chan
 224                     chan_data = s[start:start+bytes_per_chan]
 225                     rec = numpy.fromstring (chan_data, numpy.float32)
 226                     records.append (rec)
 227
 228                 # print "nrecords = %d, reclen = %d" % (len (records),nsamples)
 229
 230                 de = DataEvent (records)
 231                 wx.PostEvent (self.event_receiver, de)
 232                 records = []
 233                 del de
 234
 235             # end if iscan == 0
 236             self.iscan -= 1
 237
 238
 239 class scope_window (wx.Panel):
 240
 241     def __init__ (self, info, parent, id = -1,
 242                   pos = wx.DefaultPosition, size = wx.DefaultSize, name = ""):
 243         wx.Panel.__init__ (self, parent, -1)
 244         self.info = info
 245
 246         vbox = wx.BoxSizer (wx.VERTICAL)
 247
 248         self.graph = graph_window (info, self, -1)
 249
 250         vbox.Add (self.graph, 1, wx.EXPAND)
 251         vbox.Add (self.make_control_box(), 0, wx.EXPAND)
 252         vbox.Add (self.make_control2_box(), 0, wx.EXPAND)
 253
 254         self.sizer = vbox
 255         self.SetSizer (self.sizer)
 256         self.SetAutoLayout (True)
 257         self.sizer.Fit (self)
 258         self.set_autorange(self.info.autorange)
 259
 260
 261     # second row of control buttons etc. appears BELOW control_box
 262     def make_control2_box (self):
 263         ctrlbox = wx.BoxSizer (wx.HORIZONTAL)
 264
 265         self.inc_v_button = wx.Button (self, 1101, " < ", style=wx.BU_EXACTFIT)
 266         self.inc_v_button.SetToolTipString ("Increase vertical range")
 267         wx.EVT_BUTTON (self, 1101, self.incr_v_scale) # ID matches button ID above
 268
 269         self.dec_v_button  = wx.Button (self, 1100, " > ", style=wx.BU_EXACTFIT)
 270         self.dec_v_button.SetToolTipString ("Decrease vertical range")
 271         wx.EVT_BUTTON (self, 1100, self.decr_v_scale)
 272
 273         self.v_scale_label = wx.StaticText (self, 1002, "None") # vertical /div
 274         self.update_v_scale_label ()
 275
 276         self.autorange_checkbox = wx.CheckBox (self, 1102, "Autorange")
 277         self.autorange_checkbox.SetToolTipString ("Select autorange on/off")
 278         wx.EVT_CHECKBOX(self, 1102, self.autorange_checkbox_event)
 279
 280         ctrlbox.Add ((5,0) ,0) # left margin space
 281         ctrlbox.Add (self.inc_v_button, 0, wx.EXPAND)
 282         ctrlbox.Add (self.dec_v_button, 0, wx.EXPAND)
 283         ctrlbox.Add (self.v_scale_label, 0, wx.ALIGN_CENTER)
 284         ctrlbox.Add ((20,0) ,0) # spacer
 285         ctrlbox.Add (self.autorange_checkbox, 0, wx.ALIGN_CENTER)
 286
 287         return ctrlbox
 288
 289     def make_control_box (self):
 290         ctrlbox = wx.BoxSizer (wx.HORIZONTAL)
 291
 292         tb_left = wx.Button (self, 1001, " < ", style=wx.BU_EXACTFIT)
 293         tb_left.SetToolTipString ("Increase time base")
 294         wx.EVT_BUTTON (self, 1001, self.incr_timebase)
 295
 296
 297         tb_right  = wx.Button (self, 1000, " > ", style=wx.BU_EXACTFIT)
 298         tb_right.SetToolTipString ("Decrease time base")
 299         wx.EVT_BUTTON (self, 1000, self.decr_timebase)
 300
 301         self.time_base_label = wx.StaticText (self, 1002, "")
 302         self.update_timebase_label ()
 303
 304         ctrlbox.Add ((5,0) ,0)
 305         # ctrlbox.Add (wx.StaticText (self, -1, "Horiz Scale: "), 0, wx.ALIGN_CENTER)
 306         ctrlbox.Add (tb_left, 0, wx.EXPAND)
 307         ctrlbox.Add (tb_right, 0, wx.EXPAND)
 308         ctrlbox.Add (self.time_base_label, 0, wx.ALIGN_CENTER)
 309
 310         ctrlbox.Add ((10,0) ,1)            # stretchy space
 311
 312         ctrlbox.Add (wx.StaticText (self, -1, "Trig: "), 0, wx.ALIGN_CENTER)
 313         self.trig_chan_choice = wx.Choice (self, 1004,
 314                                            choices = ['Ch1', 'Ch2', 'Ch3', 'Ch4'])
 315         self.trig_chan_choice.SetToolTipString ("Select channel for trigger")
 316         wx.EVT_CHOICE (self, 1004, self.trig_chan_choice_event)
 317         ctrlbox.Add (self.trig_chan_choice, 0, wx.ALIGN_CENTER)
 318
 319         self.trig_mode_choice = wx.Choice (self, 1005,
 320                                            choices = ['Free', 'Auto', 'Norm'])
 321         self.trig_mode_choice.SetSelection(1)
 322         self.trig_mode_choice.SetToolTipString ("Select trigger slope or Auto (untriggered roll)")
 323         wx.EVT_CHOICE (self, 1005, self.trig_mode_choice_event)
 324         ctrlbox.Add (self.trig_mode_choice, 0, wx.ALIGN_CENTER)
 325
 326         trig_level50 = wx.Button (self, 1006, "50%")
 327         trig_level50.SetToolTipString ("Set trigger level to 50%")
 328         wx.EVT_BUTTON (self, 1006, self.set_trig_level50)
 329         ctrlbox.Add (trig_level50, 0, wx.EXPAND)
 330
 331         run_stop = wx.Button (self, 1007, "Run/Stop")
 332         run_stop.SetToolTipString ("Toggle Run/Stop mode")
 333         wx.EVT_BUTTON (self, 1007, self.run_stop)
 334         ctrlbox.Add (run_stop, 0, wx.EXPAND)
 335
 336         ctrlbox.Add ((10, 0) ,1)            # stretchy space
 337
 338         ctrlbox.Add (wx.StaticText (self, -1, "Fmt: "), 0, wx.ALIGN_CENTER)
 339         self.marker_choice = wx.Choice (self, 1002, choices = self._marker_choices)
 340         self.marker_choice.SetToolTipString ("Select plotting with lines, pluses or dots")
 341         wx.EVT_CHOICE (self, 1002, self.marker_choice_event)
 342         ctrlbox.Add (self.marker_choice, 0, wx.ALIGN_CENTER)
 343
 344         self.xy_choice = wx.Choice (self, 1003, choices = ['X:t', 'X:Y'])
 345         self.xy_choice.SetToolTipString ("Select X vs time or X vs Y display")
 346         wx.EVT_CHOICE (self, 1003, self.xy_choice_event)
 347         ctrlbox.Add (self.xy_choice, 0, wx.ALIGN_CENTER)
 348
 349         return ctrlbox
 350
 351     _marker_choices = ['line', 'plus', 'dot']
 352
 353     def update_timebase_label (self):
 354         time_per_div = self.info.get_time_per_div ()
 355         s = ' ' + eng_notation.num_to_str (time_per_div) + 's/div'
 356         self.time_base_label.SetLabel (s)
 357
 358     def decr_timebase (self, evt):
 359         self.info.time_scale_cursor.prev ()
 360         self.update_timebase_label ()
 361
 362     def incr_timebase (self, evt):
 363         self.info.time_scale_cursor.next ()
 364         self.update_timebase_label ()
 365
 366     def update_v_scale_label (self):
 367         volts_per_div = self.info.get_volts_per_div ()
 368         s = ' ' + eng_notation.num_to_str (volts_per_div) + '/div' # Not V/div
 369         self.v_scale_label.SetLabel (s)
 370
 371     def decr_v_scale (self, evt):
 372         self.info.v_scale_cursor.prev ()
 373         self.update_v_scale_label ()
 374
 375     def incr_v_scale (self, evt):
 376         self.info.v_scale_cursor.next ()
 377         self.update_v_scale_label ()
 378
 379     def marker_choice_event (self, evt):
 380         s = evt.GetString ()
 381         self.set_marker (s)
 382
 383     def set_autorange(self, on):
 384         if on:
 385             self.v_scale_label.SetLabel(" (auto)")
 386             self.info.autorange = True
 387             self.autorange_checkbox.SetValue(True)
 388             self.inc_v_button.Enable(False)
 389             self.dec_v_button.Enable(False)
 390         else:
 391             if self.graph.y_range:
 392                 (l,u) = self.graph.y_range # found by autorange
 393                 self.info.v_scale_cursor.set_index_by_value((u-l)/8.0)
 394             self.update_v_scale_label()
 395             self.info.autorange = False
 396             self.autorange_checkbox.SetValue(False)
 397             self.inc_v_button.Enable(True)
 398             self.dec_v_button.Enable(True)
 399
 400     def autorange_checkbox_event(self, evt):
 401         if evt.Checked():
 402             self.set_autorange(True)
 403         else:
 404             self.set_autorange(False)
 405
 406     def set_marker (self, s):
 407         self.info.set_marker (s)        # set info for drawing routines
 408         i = self.marker_choice.FindString (s)
 409         assert i >= 0, "Hmmm, set_marker problem"
 410         self.marker_choice.SetSelection (i)
 411
 412     def set_format_line (self):
 413         self.set_marker ('line')
 414
 415     def set_format_dot (self):
 416         self.set_marker ('dot')
 417
 418     def set_format_plus (self):
 419         self.set_marker ('plus')
 420
 421     def xy_choice_event (self, evt):
 422         s = evt.GetString ()
 423         self.info.xy = s == 'X:Y'
 424
 425     def trig_chan_choice_event (self, evt):
 426         s = evt.GetString ()
 427         ch = int (s[-1]) - 1
 428         self.info.scopesink.set_trigger_channel (ch)
 429
 430     def trig_mode_choice_event (self, evt):
 431         sink = self.info.scopesink
 432         s = evt.GetString ()
 433         if s == 'Norm':
 434             sink.set_trigger_mode (gr.gr_TRIG_MODE_NORM)
 435         elif s == 'Auto':
 436             sink.set_trigger_mode (gr.gr_TRIG_MODE_AUTO)
 437         elif s == 'Free':
 438             sink.set_trigger_mode (gr.gr_TRIG_MODE_FREE)
 439         else:
 440             assert 0, "Bad trig_mode_choice string"
 441
 442     def set_trig_level50 (self, evt):
 443         self.info.scopesink.set_trigger_level_auto ()
 444
 445     def run_stop (self, evt):
 446         self.info.running = not self.info.running
 447
 448
 449 class graph_window (plot.PlotCanvas):
 450
 451     channel_colors = ['BLUE', 'RED',
 452                       'CYAN', 'MAGENTA', 'GREEN', 'YELLOW']
 453
 454     def __init__ (self, info, parent, id = -1,
 455                   pos = wx.DefaultPosition, size = (640, 240),
 456                   style = wx.DEFAULT_FRAME_STYLE, name = ""):
 457         plot.PlotCanvas.__init__ (self, parent, id, pos, size, style, name)
 458
 459         self.SetXUseScopeTicks (True)
 460         self.SetEnableGrid (True)
 461         self.SetEnableZoom (True)
 462         self.SetEnableLegend(True)
 463         # self.SetBackgroundColour ('black')
 464
 465         self.info = info;
 466         self.y_range = None
 467         self.x_range = None
 468         self.avg_y_min = None
 469         self.avg_y_max = None
 470         self.avg_x_min = None
 471         self.avg_x_max = None
 472
 473         EVT_DATA_EVENT (self, self.format_data)
 474
 475         self.input_watcher = input_watcher (info.msgq, self, info.frame_decim)
 476
 477     def channel_color (self, ch):
 478         return self.channel_colors[ch % len(self.channel_colors)]
 479
 480     def format_data (self, evt):
 481         if not self.info.running:
 482             return
 483
 484         if self.info.xy:
 485             self.format_xy_data (evt)
 486             return
 487
 488         info = self.info
 489         records = evt.data
 490         nchannels = len (records)
 491         npoints = len (records[0])
 492
 493         objects = []
 494
 495         Ts = 1.0 / (info.get_sample_rate () / info.get_decimation_rate ())
 496         x_vals = Ts * numpy.arange (-npoints/2, npoints/2)
 497
 498         # preliminary clipping based on time axis here, instead of in graphics code
 499         time_per_window = self.info.get_time_per_div () * 10
 500         n = int (time_per_window / Ts + 0.5)
 501         n = n & ~0x1                    # make even
 502         n = max (2, min (n, npoints))
 503
 504         self.SetXUseScopeTicks (True)   # use 10 divisions, no labels
 505
 506         for ch in range(nchannels):
 507             r = records[ch]
 508
 509             # plot middle n points of record
 510
 511             lb = npoints/2 - n/2
 512             ub = npoints/2 + n/2
 513             # points = zip (x_vals[lb:ub], r[lb:ub])
 514             points = numpy.zeros ((ub-lb, 2), numpy.float64)
 515             points[:,0] = x_vals[lb:ub]
 516             points[:,1] = r[lb:ub]
 517
 518             m = info.get_marker ()
 519             if m == 'line':
 520                 objects.append (plot.PolyLine (points,
 521                                                colour=self.channel_color (ch),
 522                                                legend=('Ch%d' % (ch+1,))))
 523             else:
 524                 objects.append (plot.PolyMarker (points,
 525                                                  marker=m,
 526                                                  colour=self.channel_color (ch),
 527                                                  legend=('Ch%d' % (ch+1,))))
 528
 529         graphics = plot.PlotGraphics (objects,
 530                                       title=self.info.title,
 531                                       xLabel = '', yLabel = '')
 532
 533         time_per_div = info.get_time_per_div ()
 534         x_range = (-5.0 * time_per_div, 5.0 * time_per_div) # ranges are tuples!
 535         volts_per_div = info.get_volts_per_div ()
 536         if not self.info.autorange:
 537             self.y_range = (-4.0 * volts_per_div, 4.0 * volts_per_div)
 538         self.Draw (graphics, xAxis=x_range, yAxis=self.y_range)
 539         self.update_y_range () # autorange to self.y_range
 540
 541
 542     def format_xy_data (self, evt):
 543         info = self.info
 544         records = evt.data
 545         nchannels = len (records)
 546         npoints = len (records[0])
 547
 548         if nchannels < 2:
 549             return
 550
 551         objects = []
 552         # points = zip (records[0], records[1])
 553         points = numpy.zeros ((len(records[0]), 2), numpy.float32)
 554         points[:,0] = records[0]
 555         points[:,1] = records[1]
 556
 557         self.SetXUseScopeTicks (False)
 558
 559         m = info.get_marker ()
 560         if m == 'line':
 561             objects.append (plot.PolyLine (points,
 562                                            colour=self.channel_color (0)))
 563         else:
 564             objects.append (plot.PolyMarker (points,
 565                                              marker=m,
 566                                              colour=self.channel_color (0)))
 567
 568         graphics = plot.PlotGraphics (objects,
 569                                       title=self.info.title,
 570                                       xLabel = 'I', yLabel = 'Q')
 571
 572         self.Draw (graphics, xAxis=self.x_range, yAxis=self.y_range)
 573         self.update_y_range ()
 574         self.update_x_range ()
 575
 576
 577     def update_y_range (self):
 578         alpha = 1.0/25
 579         graphics = self.last_draw[0]
 580         p1, p2 = graphics.boundingBox ()     # min, max points of graphics
 581
 582         if self.avg_y_min: # prevent vertical scale from jumping abruptly --?
 583             self.avg_y_min = p1[1] * alpha + self.avg_y_min * (1 - alpha)
 584             self.avg_y_max = p2[1] * alpha + self.avg_y_max * (1 - alpha)
 585         else: # initial guess
 586             self.avg_y_min = p1[1] # -500.0 workaround, sometimes p1 is ~ 10^35
 587             self.avg_y_max = p2[1] # 500.0
 588
 589         self.y_range = self._axisInterval ('auto', self.avg_y_min, self.avg_y_max)
 590         # print "p1 %s  p2 %s  y_min %s  y_max %s  y_range %s" \
 591         #        % (p1, p2, self.avg_y_min, self.avg_y_max, self.y_range)
 592
 593
 594     def update_x_range (self):
 595         alpha = 1.0/25
 596         graphics = self.last_draw[0]
 597         p1, p2 = graphics.boundingBox ()     # min, max points of graphics
 598
 599         if self.avg_x_min:
 600             self.avg_x_min = p1[0] * alpha + self.avg_x_min * (1 - alpha)
 601             self.avg_x_max = p2[0] * alpha + self.avg_x_max * (1 - alpha)
 602         else:
 603             self.avg_x_min = p1[0]
 604             self.avg_x_max = p2[0]
 605
 606         self.x_range = self._axisInterval ('auto', self.avg_x_min, self.avg_x_max)
 607
 608
 609 # ----------------------------------------------------------------
 610 # Stand-alone test application
 611 # ----------------------------------------------------------------
 612
 613 class test_top_block (stdgui2.std_top_block):
 614     def __init__(self, frame, panel, vbox, argv):
 615         stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
 616
 617         if len(argv) > 1:
 618             frame_decim = int(argv[1])
 619         else:
 620             frame_decim = 1
 621
 622         if len(argv) > 2:
 623             v_scale = float(argv[2])  # start up at this v_scale value
 624         else:
 625             v_scale = None  # start up in autorange mode, default
 626
 627         if len(argv) > 3:
 628             t_scale = float(argv[3])  # start up at this t_scale value
 629         else:
 630             t_scale = None  # old behavior
 631
 632         print "frame decim %s  v_scale %s  t_scale %s" % (frame_decim,v_scale,t_scale)
 633
 634         input_rate = 1e6
 635
 636         # Generate a complex sinusoid
 637         self.src0 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 25.1e3, 1e3)
 638
 639         # We add this throttle block so that this demo doesn't suck down
 640         # all the CPU available.  You normally wouldn't use it...
 641         self.thr = gr.throttle(gr.sizeof_gr_complex, input_rate)
 642
 643         scope = scope_sink_c (panel,"Secret Data",sample_rate=input_rate,
 644                               frame_decim=frame_decim,
 645                               v_scale=v_scale, t_scale=t_scale)
 646         vbox.Add (scope.win, 1, wx.EXPAND)
 647
 648         # Ultimately this will be
 649         # self.connect("src0 throttle scope")
 650         self.connect(self.src0, self.thr, scope)
 651
 652 def main ():
 653     app = stdgui2.stdapp (test_top_block, "O'Scope Test App")
 654     app.MainLoop ()
 655
 656 if __name__ == '__main__':
 657     main ()
 658
 659 # ----------------------------------------------------------------