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

   1 #
   2 # Copyright 2008,2009 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 waterfall_window
  26 import common
  27 from gnuradio import gr, blks2
  28 from pubsub import pubsub
  29 from constants import *
  30
  31 ##################################################
  32 # Waterfall sink block (wrapper for old wxgui)
  33 ##################################################
  34 class _waterfall_sink_base(gr.hier_block2, common.wxgui_hb):
  35         """
  36         An fft block with real/complex inputs and a gui window.
  37         """
  38
  39         def __init__(
  40                 self,
  41                 parent,
  42                 baseband_freq=0,
  43                 ref_level=50,
  44                 sample_rate=1,
  45                 fft_size=512,
  46                 fft_rate=waterfall_window.DEFAULT_FRAME_RATE,
  47                 average=False,
  48                 avg_alpha=None,
  49                 title='',
  50                 size=waterfall_window.DEFAULT_WIN_SIZE,
  51                 ref_scale=2.0,
  52                 dynamic_range=80,
  53                 num_lines=256,
  54                 win=None,
  55                 **kwargs #do not end with a comma
  56         ):
  57                 #ensure avg alpha
  58                 if avg_alpha is None: avg_alpha = 2.0/fft_rate
  59                 #init
  60                 gr.hier_block2.__init__(
  61                         self,
  62                         "waterfall_sink",
  63                         gr.io_signature(1, 1, self._item_size),
  64                         gr.io_signature(0, 0, 0),
  65                 )
  66                 #blocks
  67                 fft = self._fft_chain(
  68                         sample_rate=sample_rate,
  69                         fft_size=fft_size,
  70                         frame_rate=fft_rate,
  71                         ref_scale=ref_scale,
  72                         avg_alpha=avg_alpha,
  73                         average=average,
  74                         win=win,
  75                 )
  76                 msgq = gr.msg_queue(2)
  77                 sink = gr.message_sink(gr.sizeof_float*fft_size, msgq, True)
  78                 #controller
  79                 self.controller = pubsub()
  80                 self.controller.subscribe(AVERAGE_KEY, fft.set_average)
  81                 self.controller.publish(AVERAGE_KEY, fft.average)
  82                 self.controller.subscribe(AVG_ALPHA_KEY, fft.set_avg_alpha)
  83                 self.controller.publish(AVG_ALPHA_KEY, fft.avg_alpha)
  84                 self.controller.subscribe(SAMPLE_RATE_KEY, fft.set_sample_rate)
  85                 self.controller.publish(SAMPLE_RATE_KEY, fft.sample_rate)
  86                 self.controller.subscribe(DECIMATION_KEY, fft.set_decimation)
  87                 self.controller.publish(DECIMATION_KEY, fft.decimation)
  88                 self.controller.subscribe(FRAME_RATE_KEY, fft.set_vec_rate)
  89                 self.controller.publish(FRAME_RATE_KEY, fft.frame_rate)
  90                 #start input watcher
  91                 common.input_watcher(msgq, self.controller, MSG_KEY)
  92                 #create window
  93                 self.win = waterfall_window.waterfall_window(
  94                         parent=parent,
  95                         controller=self.controller,
  96                         size=size,
  97                         title=title,
  98                         real=self._real,
  99                         fft_size=fft_size,
 100                         num_lines=num_lines,
 101                         baseband_freq=baseband_freq,
 102                         decimation_key=DECIMATION_KEY,
 103                         sample_rate_key=SAMPLE_RATE_KEY,
 104                         frame_rate_key=FRAME_RATE_KEY,
 105                         dynamic_range=dynamic_range,
 106                         ref_level=ref_level,
 107                         average_key=AVERAGE_KEY,
 108                         avg_alpha_key=AVG_ALPHA_KEY,
 109                         msg_key=MSG_KEY,
 110                 )
 111                 common.register_access_methods(self, self.win)
 112                 setattr(self.win, 'set_baseband_freq', getattr(self, 'set_baseband_freq')) #BACKWARDS
 113                 #connect
 114                 self.wxgui_connect(self, fft, sink)
 115
 116 class waterfall_sink_f(_waterfall_sink_base):
 117         _fft_chain = blks2.logpwrfft_f
 118         _item_size = gr.sizeof_float
 119         _real = True
 120
 121 class waterfall_sink_c(_waterfall_sink_base):
 122         _fft_chain = blks2.logpwrfft_c
 123         _item_size = gr.sizeof_gr_complex
 124         _real = False
 125
 126 # ----------------------------------------------------------------
 127 # Standalone test app
 128 # ----------------------------------------------------------------
 129
 130 import wx
 131 from gnuradio.wxgui import stdgui2
 132
 133 class test_top_block (stdgui2.std_top_block):
 134     def __init__(self, frame, panel, vbox, argv):
 135         stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
 136
 137         fft_size = 512
 138
 139         # build our flow graph
 140         input_rate = 20.000e3
 141
 142         # Generate a complex sinusoid
 143         self.src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000)
 144         #src1 = gr.sig_source_c (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1000)
 145
 146         # We add these throttle blocks so that this demo doesn't
 147         # suck down all the CPU available.  Normally you wouldn't use these.
 148         self.thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate)
 149
 150         sink1 = waterfall_sink_c (panel, title="Complex Data", fft_size=fft_size,
 151                                   sample_rate=input_rate, baseband_freq=100e3)
 152         self.connect(self.src1, self.thr1, sink1)
 153         vbox.Add (sink1.win, 1, wx.EXPAND)
 154
 155         # generate a real sinusoid
 156         self.src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000)
 157         self.thr2 = gr.throttle(gr.sizeof_float, input_rate)
 158         sink2 = waterfall_sink_f (panel, title="Real Data", fft_size=fft_size,
 159                                   sample_rate=input_rate, baseband_freq=100e3)
 160         self.connect(self.src2, self.thr2, sink2)
 161         vbox.Add (sink2.win, 1, wx.EXPAND)
 162
 163
 164 def main ():
 165     app = stdgui2.stdapp (test_top_block, "Waterfall Sink Test App")
 166     app.MainLoop ()
 167
 168 if __name__ == '__main__':
 169     main ()
 170