#!/usr/bin/env python
#
-# Copyright 2003,2004,2005 Free Software Foundation, Inc.
+# Copyright 2003,2004,2005,2007 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
#
from gnuradio import gr, gru, window
-from gnuradio.wxgui import stdgui
+from gnuradio.wxgui import stdgui2
import wx
import gnuradio.wxgui.plot as plot
-import Numeric
+import numpy
import threading
import math
import random
default_ra_fftsink_size = (640,140)
-def default_cfunc(db,l):
- return(db)
-
class ra_fft_sink_base(object):
def __init__(self, input_is_real=False, baseband_freq=0, y_per_div=10, sc_y_per_div=0.5, ref_level=50, sc_ref_level=20,
sample_rate=1, fft_size=512, fft_rate=15,
- average=False, avg_alpha=None, title='', peak_hold=False, cfunc=default_cfunc, xydfunc=None, interfunc=None):
+ average=False, avg_alpha=None, title='', peak_hold=False, ofunc=None, xydfunc=None):
# initialize common attributes
self.baseband_freq = baseband_freq
self.fft_rate = fft_rate
self.binwidth = float(sample_rate/fft_size)
self.average = average
- self.cfunc = cfunc
+ self.ofunc = ofunc
self.xydfunc = xydfunc
- self.interfunc = interfunc
+ self.ofunc = ofunc
if avg_alpha is None:
self.avg_alpha = 2.0 / fft_rate
else:
self.baseband_freq = baseband_freq
-class ra_fft_sink_f(gr.hier_block, ra_fft_sink_base):
- def __init__(self, fg, parent, baseband_freq=0,
+class ra_fft_sink_f(gr.hier_block2, ra_fft_sink_base):
+ def __init__(self, parent, baseband_freq=0,
y_per_div=10, sc_y_per_div=0.5, sc_ref_level=40, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=15, average=False, avg_alpha=None, title='',
- size=default_ra_fftsink_size, peak_hold=False, cfunc=default_cfunc, xydfunc=None, interfunc=None):
-
+ size=default_ra_fftsink_size, peak_hold=False, ofunc=None,
+ xydfunc=None):
+ gr.hier_block2.__init__(self, "ra_fft_sink_f",
+ gr.io_signature(1, 1, gr.sizeof_float),
+ gr.io_signature(0, 0, 0))
+
ra_fft_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
y_per_div=y_per_div, sc_y_per_div=sc_y_per_div,
sc_ref_level=sc_ref_level, ref_level=ref_level,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title,
- peak_hold=peak_hold, cfunc=cfunc,
- xydfunc=xydfunc, interfunc=interfunc)
+ peak_hold=peak_hold, ofunc=ofunc,
+ xydfunc=xydfunc)
self.binwidth = float(sample_rate/2.0)/float(fft_size)
s2p = gr.serial_to_parallel(gr.sizeof_float, fft_size)
log = gr.nlog10_ff(20, fft_size, -20*math.log10(fft_size))
sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True)
- fg.connect (s2p, one_in_n, fft, c2mag, self.avg, log, sink)
- gr.hier_block.__init__(self, fg, s2p, sink)
+ self.connect (self, s2p, one_in_n, fft, c2mag, self.avg, log, sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
-class ra_fft_sink_c(gr.hier_block, ra_fft_sink_base):
- def __init__(self, fg, parent, baseband_freq=0,
+class ra_fft_sink_c(gr.hier_block2, ra_fft_sink_base):
+ def __init__(self, parent, baseband_freq=0,
y_per_div=10, sc_y_per_div=0.5, sc_ref_level=40,
ref_level=50, sample_rate=1, fft_size=512,
fft_rate=15, average=False, avg_alpha=None, title='',
- size=default_ra_fftsink_size, peak_hold=False, cfunc=default_cfunc, xydfunc=None, interfunc=None):
+ size=default_ra_fftsink_size, peak_hold=False, ofunc=None, xydfunc=None):
+
+ gr.hier_block2.__init__(self, "ra_fft_sink_c",
+ gr.io_signature(1, 1, gr.sizeof_gr_complex),
+ gr.io_signature(0, 0, 0))
+
ra_fft_sink_base.__init__(self, input_is_real=False, baseband_freq=baseband_freq,
y_per_div=y_per_div, sc_y_per_div=sc_y_per_div,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha,
title=title,
- peak_hold=peak_hold, cfunc=cfunc,
- xydfunc=xydfunc, interfunc=interfunc)
+ peak_hold=peak_hold, ofunc=ofunc,
+ xydfunc=xydfunc)
s2p = gr.serial_to_parallel(gr.sizeof_gr_complex, fft_size)
one_in_n = gr.keep_one_in_n(gr.sizeof_gr_complex * fft_size,
log = gr.nlog10_ff(20, fft_size, -20*math.log10(fft_size))
sink = gr.message_sink(gr.sizeof_float * fft_size, self.msgq, True)
- fg.connect(s2p, one_in_n, fft, c2mag, self.avg, log, sink)
- gr.hier_block.__init__(self, fg, s2p, sink)
+ self.connect(self, s2p, one_in_n, fft, c2mag, self.avg, log, sink)
self.win = fft_window(self, parent, size=size)
self.set_average(self.average)
start = itemsize * (nitems - 1)
s = s[start:start+itemsize]
- complex_data = Numeric.fromstring (s, Numeric.Float32)
+ complex_data = numpy.fromstring (s, numpy.float32)
de = DataEvent (complex_data)
wx.PostEvent (self.event_receiver, de)
del de
EVT_DATA_EVENT (self, self.set_data)
wx.EVT_CLOSE (self, self.on_close_window)
self.Bind(wx.EVT_RIGHT_UP, self.on_right_click)
- self.Bind(wx.EVT_MOTION, self.on_motion)
self.Bind(wx.EVT_LEFT_UP, self.on_left_click)
+ self.Bind(wx.EVT_MOTION, self.on_motion)
self.input_watcher = input_watcher(ra_fftsink.msgq, ra_fftsink.fft_size, self)
calc_min = min(dB)
calc_max = max(dB)
-
- dB = self.ra_fftsink.cfunc(dB, L)
+ if (self.ra_fftsink.ofunc != None):
+ self.ra_fftsink.ofunc(evt.data,L)
+
if self.peak_hold:
if self.peak_vals is None:
self.peak_vals = dB
else:
- self.peak_vals = Numeric.maximum(dB, self.peak_vals)
+ self.peak_vals = numpy.maximum(dB, self.peak_vals)
dB = self.peak_vals
x = max(abs(self.ra_fftsink.sample_rate), abs(self.ra_fftsink.baseband_freq))
units = "Hz"
if self.ra_fftsink.input_is_real: # only plot 1/2 the points
- x_vals = ((Numeric.arrayrange (L/2)
+ x_vals = ((numpy.arange (L/2)
* (self.ra_fftsink.sample_rate * sf / L))
+ self.ra_fftsink.baseband_freq * sf)
- points = Numeric.zeros((len(x_vals), 2), Numeric.Float64)
+ points = numpy.zeros((len(x_vals), 2), numpy.float64)
points[:,0] = x_vals
points[:,1] = dB[0:L/2]
else:
# the "negative freqs" are in the second half of the array
- x_vals = ((Numeric.arrayrange (-L/2, L/2)
+ x_vals = ((numpy.arange(-L/2, L/2)
* (self.ra_fftsink.sample_rate * sf / L))
+ self.ra_fftsink.baseband_freq * sf)
- points = Numeric.zeros((len(x_vals), 2), Numeric.Float64)
+ points = numpy.zeros((len(x_vals), 2), numpy.float64)
points[:,0] = x_vals
- points[:,1] = Numeric.concatenate ((dB[L/2:], dB[0:L/2]))
+ points[:,1] = numpy.concatenate ((dB[L/2:], dB[0:L/2]))
lines = plot.PolyLine (points, colour='BLUE')
graphics = plot.PlotGraphics ([lines],
self.Draw (graphics, xAxis=None, yAxis=self.y_range)
d = calc_max - calc_min
- d *= 0.1
+ d = d * 0.1
if self.ra_fftsink.autoscale == True:
self.y_range = self._axisInterval ('min', calc_min-d, calc_max+d)
else:
def on_motion(self, event):
if not self.ra_fftsink.xydfunc == None:
xy = self.GetXY(event)
- self.ra_fftsink.xydfunc (xy)
-
- def on_left_click(self, event):
- if not self.ra_fftsink.interfunc == None:
+ self.ra_fftsink.xydfunc (0,xy)
+
+ def on_left_click(self,event):
+ if not self.ra_fftsink.xydfunc == None:
xy = self.GetXY(event)
- self.ra_fftsink.interfunc (xy[0])
+ self.ra_fftsink.xydfunc (1,xy)
def build_popup_menu(self):
self.id_incr_ref_level = wx.NewId()
return v
-# ----------------------------------------------------------------
-# Deprecated interfaces
-# ----------------------------------------------------------------
-
-# returns (block, win).
-# block requires a single input stream of float
-# win is a subclass of wxWindow
-
-def make_ra_fft_sink_f(fg, parent, title, fft_size, input_rate, ymin = 0, ymax=50):
-
- block = ra_fft_sink_f(fg, parent, title=title, fft_size=fft_size, sample_rate=input_rate,
- y_per_div=(ymax - ymin)/8, ref_level=ymax)
- return (block, block.win)
-
-# returns (block, win).
-# block requires a single input stream of gr_complex
-# win is a subclass of wxWindow
-
-def make_ra_fft_sink_c(fg, parent, title, fft_size, input_rate, ymin=0, ymax=50):
- block = ra_fft_sink_c(fg, parent, title=title, fft_size=fft_size, sample_rate=input_rate,
- y_per_div=(ymax - ymin)/8, ref_level=ymax)
- return (block, block.win)
-
-
# ----------------------------------------------------------------
# Standalone test app
# ----------------------------------------------------------------
-class test_app_flow_graph (stdgui.gui_flow_graph):
+class test_app_flow_graph (stdgui2.std_top_block):
def __init__(self, frame, panel, vbox, argv):
- stdgui.gui_flow_graph.__init__ (self, frame, panel, vbox, argv)
+ stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
fft_size = 256
# suck down all the CPU available. Normally you wouldn't use these.
thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate)
- sink1 = ra_fft_sink_c (self, panel, title="Complex Data", fft_size=fft_size,
+ sink1 = ra_fft_sink_c (panel, title="Complex Data", fft_size=fft_size,
sample_rate=input_rate, baseband_freq=100e3,
ref_level=60, y_per_div=10)
vbox.Add (sink1.win, 1, wx.EXPAND)
src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000)
#src2 = gr.sig_source_f (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1000)
thr2 = gr.throttle(gr.sizeof_float, input_rate)
- sink2 = ra_fft_sink_f (self, panel, title="Real Data", fft_size=fft_size*2,
+ sink2 = ra_fft_sink_f (panel, title="Real Data", fft_size=fft_size*2,
sample_rate=input_rate, baseband_freq=100e3,
ref_level=60, y_per_div=10)
vbox.Add (sink2.win, 1, wx.EXPAND)
self.connect (src2, thr2, sink2)
def main ():
- app = stdgui.stdapp (test_app_flow_graph,
+ app = stdgui2.stdapp (test_app_flow_graph,
"FFT Sink Test App")
app.MainLoop ()
projects / debian / gnuradio / blobdiff