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

   1 #
   2 # Copyright 2008,2010 Free Software Foundation, Inc.
   3 #
   4 # This file is part of GNU Radio
   5 #
   6 # GNU Radio is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 3, or (at your option)
   9 # any later version.
  10 #
  11 # GNU Radio is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with GNU Radio; see the file COPYING.  If not, write to
  18 # the Free Software Foundation, Inc., 51 Franklin Street,
  19 # Boston, MA 02110-1301, USA.
  20 #
  21
  22 ##################################################
  23 # Imports
  24 ##################################################
  25 import scope_window
  26 import common
  27 from gnuradio import gr
  28 from pubsub import pubsub
  29 from constants import *
  30 import math
  31
  32 class ac_couple_block(gr.hier_block2):
  33         """
  34         AC couple the incoming stream by subtracting out the low pass signal.
  35         Mute the low pass filter to disable ac coupling.
  36         """
  37
  38         def __init__(self, controller, ac_couple_key, sample_rate_key):
  39                 gr.hier_block2.__init__(
  40                         self,
  41                         "ac_couple",
  42                         gr.io_signature(1, 1, gr.sizeof_float),
  43                         gr.io_signature(1, 1, gr.sizeof_float),
  44                 )
  45                 #blocks
  46                 lpf = gr.single_pole_iir_filter_ff(0.0)
  47                 sub = gr.sub_ff()
  48                 mute = gr.mute_ff()
  49                 #connect
  50                 self.connect(self, sub, self)
  51                 self.connect(self, lpf, mute, (sub, 1))
  52                 #subscribe
  53                 controller.subscribe(ac_couple_key, lambda x: mute.set_mute(not x))
  54                 controller.subscribe(sample_rate_key, lambda x: lpf.set_taps(0.05))
  55                 #initialize
  56                 controller[ac_couple_key] = controller[ac_couple_key]
  57                 controller[sample_rate_key] = controller[sample_rate_key]
  58
  59 ##################################################
  60 # Scope sink block (wrapper for old wxgui)
  61 ##################################################
  62 class _scope_sink_base(gr.hier_block2, common.wxgui_hb):
  63         """
  64         A scope block with a gui window.
  65         """
  66
  67         def __init__(
  68                 self,
  69                 parent,
  70                 title='',
  71                 sample_rate=1,
  72                 size=scope_window.DEFAULT_WIN_SIZE,
  73                 v_scale=0,
  74                 t_scale=0,
  75                 v_offset=0,
  76                 xy_mode=False,
  77                 ac_couple=False,
  78                 num_inputs=1,
  79                 trig_mode=scope_window.DEFAULT_TRIG_MODE,
  80                 y_axis_label='Counts',
  81                 frame_rate=scope_window.DEFAULT_FRAME_RATE,
  82                 use_persistence=False,
  83                 persist_alpha=None,
  84                 **kwargs #do not end with a comma
  85         ):
  86                 #ensure analog alpha
  87                 if persist_alpha is None:
  88                   actual_frame_rate=float(frame_rate)
  89                   analog_cutoff_freq=0.5 # Hertz
  90                   #calculate alpha from wanted cutoff freq
  91                   persist_alpha = 1.0 - math.exp(-2.0*math.pi*analog_cutoff_freq/actual_frame_rate)
  92
  93                 if not t_scale: t_scale = 10.0/sample_rate
  94                 #init
  95                 gr.hier_block2.__init__(
  96                         self,
  97                         "scope_sink",
  98                         gr.io_signature(num_inputs, num_inputs, self._item_size),
  99                         gr.io_signature(0, 0, 0),
 100                 )
 101                 #scope
 102                 msgq = gr.msg_queue(2)
 103                 scope = gr.oscope_sink_f(sample_rate, msgq)
 104                 #controller
 105                 self.controller = pubsub()
 106                 self.controller.subscribe(SAMPLE_RATE_KEY, scope.set_sample_rate)
 107                 self.controller.publish(SAMPLE_RATE_KEY, scope.sample_rate)
 108                 self.controller.subscribe(DECIMATION_KEY, scope.set_decimation_count)
 109                 self.controller.publish(DECIMATION_KEY, scope.get_decimation_count)
 110                 self.controller.subscribe(TRIGGER_LEVEL_KEY, scope.set_trigger_level)
 111                 self.controller.publish(TRIGGER_LEVEL_KEY, scope.get_trigger_level)
 112                 self.controller.subscribe(TRIGGER_MODE_KEY, scope.set_trigger_mode)
 113                 self.controller.publish(TRIGGER_MODE_KEY, scope.get_trigger_mode)
 114                 self.controller.subscribe(TRIGGER_SLOPE_KEY, scope.set_trigger_slope)
 115                 self.controller.publish(TRIGGER_SLOPE_KEY, scope.get_trigger_slope)
 116                 self.controller.subscribe(TRIGGER_CHANNEL_KEY, scope.set_trigger_channel)
 117                 self.controller.publish(TRIGGER_CHANNEL_KEY, scope.get_trigger_channel)
 118                 actual_num_inputs = self._real and num_inputs or num_inputs*2
 119                 #init ac couple
 120                 for i in range(actual_num_inputs):
 121                         self.controller[common.index_key(AC_COUPLE_KEY, i)] = ac_couple
 122                 #start input watcher
 123                 common.input_watcher(msgq, self.controller, MSG_KEY)
 124                 #create window
 125                 self.win = scope_window.scope_window(
 126                         parent=parent,
 127                         controller=self.controller,
 128                         size=size,
 129                         title=title,
 130                         frame_rate=frame_rate,
 131                         num_inputs=actual_num_inputs,
 132                         sample_rate_key=SAMPLE_RATE_KEY,
 133                         t_scale=t_scale,
 134                         v_scale=v_scale,
 135                         v_offset=v_offset,
 136                         xy_mode=xy_mode,
 137                         trig_mode=trig_mode,
 138                         y_axis_label=y_axis_label,
 139                         ac_couple_key=AC_COUPLE_KEY,
 140                         trigger_level_key=TRIGGER_LEVEL_KEY,
 141                         trigger_mode_key=TRIGGER_MODE_KEY,
 142                         trigger_slope_key=TRIGGER_SLOPE_KEY,
 143                         trigger_channel_key=TRIGGER_CHANNEL_KEY,
 144                         decimation_key=DECIMATION_KEY,
 145                         msg_key=MSG_KEY,
 146                         use_persistence=use_persistence,
 147                         persist_alpha=persist_alpha,
 148                 )
 149                 common.register_access_methods(self, self.win)
 150                 #connect
 151                 if self._real:
 152                         for i in range(num_inputs):
 153                                 self.wxgui_connect(
 154                                         (self, i),
 155                                         ac_couple_block(self.controller, common.index_key(AC_COUPLE_KEY, i), SAMPLE_RATE_KEY),
 156                                         (scope, i),
 157                                 )
 158                 else:
 159                         for i in range(num_inputs):
 160                                 c2f = gr.complex_to_float()
 161                                 self.wxgui_connect((self, i), c2f)
 162                                 for j in range(2):
 163                                         self.connect(
 164                                                 (c2f, j),
 165                                                 ac_couple_block(self.controller, common.index_key(AC_COUPLE_KEY, 2*i+j), SAMPLE_RATE_KEY),
 166                                                 (scope, 2*i+j),
 167                                         )
 168
 169 class scope_sink_f(_scope_sink_base):
 170         _item_size = gr.sizeof_float
 171         _real = True
 172
 173 class scope_sink_c(_scope_sink_base):
 174         _item_size = gr.sizeof_gr_complex
 175         _real = False
 176
 177 # ----------------------------------------------------------------
 178 # Stand-alone test application
 179 # ----------------------------------------------------------------
 180
 181 import wx
 182 from gnuradio.wxgui import stdgui2
 183
 184 class test_top_block (stdgui2.std_top_block):
 185     def __init__(self, frame, panel, vbox, argv):
 186         stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
 187
 188         default_input_rate = 1e6
 189         if len(argv) > 1:
 190             input_rate = int(argv[1])
 191         else:
 192             input_rate = default_input_rate
 193
 194         if len(argv) > 2:
 195             v_scale = float(argv[2])  # start up at this v_scale value
 196         else:
 197             v_scale = None  # start up in autorange mode, default
 198
 199         if len(argv) > 3:
 200             t_scale = float(argv[3])  # start up at this t_scale value
 201         else:
 202             t_scale = .00003*default_input_rate/input_rate # old behavior
 203
 204         print "input rate %s  v_scale %s  t_scale %s" % (input_rate,v_scale,t_scale)
 205
 206
 207         # Generate a complex sinusoid
 208         ampl=1.0e3
 209         self.src0 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 25.1e3*input_rate/default_input_rate, ampl)
 210         self.noise =gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 11.1*25.1e3*input_rate/default_input_rate, ampl/10)
 211         #self.noise =gr.noise_source_c(gr.GR_GAUSSIAN, ampl/10)
 212         self.combine=gr.add_cc()
 213
 214         # We add this throttle block so that this demo doesn't suck down
 215         # all the CPU available.  You normally wouldn't use it...
 216         self.thr = gr.throttle(gr.sizeof_gr_complex, input_rate)
 217
 218         scope = scope_sink_c (panel,"Secret Data",sample_rate=input_rate,
 219                               v_scale=v_scale, t_scale=t_scale)
 220         vbox.Add (scope.win, 1, wx.EXPAND)
 221
 222         # Ultimately this will be
 223         # self.connect("src0 throttle scope")
 224         self.connect(self.src0,(self.combine,0))
 225         self.connect(self.noise,(self.combine,1))
 226         self.connect(self.combine, self.thr, scope)
 227
 228 def main ():
 229     app = stdgui2.stdapp (test_top_block, "O'Scope Test App")
 230     app.MainLoop ()
 231
 232 if __name__ == '__main__':
 233     main ()