[Discuss-gnuradio] Capture first 512 data samples every second

[sunflower]

Hi, Can anybody help me if I want to capture the first 512 data samples
every second? I want to display data samples using GUI scope_sink as
well.
I try to used gr.head(). But I don't know how to put gr.run() into
_build_gui() casue it is using stdgui.stdapp instead of build_graph()

here is my code:

Thank you in advance.







#!/usr/bin/env python

from gnuradio import gr, gru, eng_notation, optfir
from gnuradio import audio
from gnuradio import usrp
from gnuradio import blks
from gnuradio.eng_option import eng_option
from gnuradio.wxgui import slider, powermate
from gnuradio.wxgui import stdgui, fftsink, scopesink, form
from optparse import OptionParser
import usrp_dbid
import sys
import math
import wx

def pick_subdevice(u):
    return usrp.pick_subdev(u, (usrp_dbid.TV_RX,
                                usrp_dbid.BASIC_RX))


class cadi_rcvr_graph (stdgui.gui_flow_graph):
    def __init__(self,frame,panel,vbox,argv):
        stdgui.gui_flow_graph.__init__ (self,frame,panel,vbox,argv)
        parser=OptionParser(option_class=eng_option
)
        parser.add_option("-R", "--rx-subdev-spec", 
type="subdev", default=None
,
                          help="select USRP Rx side A or B (default=A)")
        parser.add_option("-f", "--freq", 
type="eng_float", default=5e6
,
                          help="set frequency to FREQ", metavar=
"FREQ")
        (options, args) = parser.parse_args
()
        if len(args) != 
0:
            parser.print_help()
            sys.exit(1)

        self.frame = frame
        self.panel = panel
        nsamples = 1024 

        # build graph
        self.u = usrp.source_c()                    
# usrp is data source
        adc_rate = self.u.adc_rate()
                # 64 MS/s
        usrp_decim = 160
        self.u.set_decim_rate(usrp_decim)
        usrp_rate = adc_rate / usrp_decim           
# 400 kS/s
        data_decim = 4
        data_rate = usrp_rate / data_decim

        if options.rx_subdev_spec is None:
            options.rx_subdev_spec = pick_subdevice(self.u
)

        self.u.set_mux(usrp.determine_rx_mux_value(
self.u, options.rx_subdev_spec))
        self.u.set_pga(0,10
)
        self.u.set_rx_freq(0,options.freq)

        
        self.subdev = usrp.selected_subdev(self
.u, options.rx_subdev_spec)
        print "Using RX d'board %s" 
% (self.subdev.side_and_name(),)

        gain=1.0
       # Decimation filter
        cutoff_freq=120e3
        transition_band=20e3
        decfilt_coeffs = gr.firdes.low_pass (gain,                     # gain

                                             chanfilt_rate,            # sampling rate
                                             cutoff_freq,              # low pass cutoff freq
                                             transition_band,          # width of trans. band
                                             gr.firdes.WIN_HAMMING)
        self.dec_filter = gr.fir_filter_ccf(data_decim, decfilt_coeffs
)

        self.head = gr.head(gr.sizeof_gr_complex, nsamples
)

        file_sink = gr.file_sink (gr.sizeof_gr_complex, 
"/home/rx.txt")
        self.connect (self.u, self.dec_filter, 
self.head, file_sink)
        self._build_gui(vbox, usrp_rate, data_rate)

    def _build_gui(self, vbox, usrp_rate, data_rate):
        if 1:
            self.post_filt_time = \
                      scopesink.scope_sink_c (self, self.panel, 
"Complex",data_rate)
            self.connect (self.dec_filter, self
.post_filt_time)
            vbox.Add (self.post_filt_time.win, 4, wx.EXPAND
)
            
        if 1:
            self.post_filt_time_part = \
                      scopesink.scope_sink_c (self, self.panel, 
"Complex",data_rate)
            self.connect (self.head, self.post_filt_time_part
)
            vbox.Add (self.post_filt_time_part.win, 4, wx.EXPAND
)

if __name__ == '__main__':
    app = stdgui.stdapp (cadi_rcvr_graph, "CADI RX"
)
    app.MainLoop ()