[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Discuss-gnuradio] top_block/flowgraph problem

From: Aadil Volkwin
Subject: [Discuss-gnuradio] top_block/flowgraph problem
Date: Mon, 24 Mar 2008 18:11:49 +0200

I am using two TVRx modules on the same motherboard to write a 1 second sample every minute for 30mins. theoretically I should have 60 sample sets, collectively.

I am able to write the first sample set succesfully but all writes after that fail!

Please take a moment to look at what I may be doing wrong.

with thanks.


class my_top_block(gr.top_block):

    def __init__(self):

        usage="%prog: [options] output_filename0 output_filename1 "
        parser = OptionParser(option_class=eng_option, usage=usage)
        parser.add_option("-R", "--rx-subdev-spec0", type="subdev", default=None,
                        help="first channel select USRP Rx side A or B (default=A)")
        parser.add_option("-r", "--rx-subdev-spec1", type="subdev", default=None,
                        help="second channel select USRP Rx side A or B (default=A)")           
        parser.add_option("-d", "--decim", type="int", default=256,
                        help="set fgpa decimation rate to DECIM [default=%default]")
        parser.add_option("-f", "--freq", type="eng_float", default=100e6,
                        help="set frequency to FREQ", metavar="FREQ")
        parser.add_option("-g", "--gain", type="eng_float", default=None,
                        help="set gain in dB (default is midpoint)")
        parser.add_option("-N", "--nsamples", type="eng_float", default=9600000,
                        help="number of samples to collect [default=9600000]")
        parser.add_option("-t", "--time", type="eng_float", default=0,
                        help="length of recording in seconds [default=0]")
        (options, args) = parser.parse_args ()
        decim_rate = options.decim
        if options.time:   
            options.nsamples = int(float(options.time) * 64e6 / float(decim_rate))
            options.time = float(options.nsamples / (64e6 / float(decim_rate)) )

        if options.freq is None:
            sys.stderr.write('You must specify the frequency with -f FREQ\n');
            raise SystemExit, 1

        # setup USRP source
        self.u = usrp.source_c(decim_rate = options.decim, nchan = 2)
        # set up daughterboard positions and subdevices
        if options.rx_subdev_spec0 is None:
            options.rx_subdev_spec0 = (0,0)
        if options.rx_subdev_spec1 is None:
            options.rx_subdev_spec1 = (1,0)
        # determine the daughterboard subdevice we're using
        self.subdev0 = usrp.selected_subdev(self.u, options.rx_subdev_spec0)
        self.subdev1 = usrp.selected_subdev(self.u, options.rx_subdev_spec1)

        #setup Mux
        mux_val0 = usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec0)
        mux_val1 = usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec1)
        mux_val0 |= (mux_val1 <<  8) & 0xff00
        if options.gain is None:
            # if no gain was specified, use the mid-point in dB
            g0 = self.subdev0.gain_range()
            g1 = self.subdev1.gain_range()
            options.gain = float(g0[0]+g0[1])/2

        ddc = -19.9e6
        self.subdev = (self.subdev0, self.subdev1)
        #Tune daughterboards       
        for n in range(2):
            ok, baseband_freq = self.subdev[n].set_freq(options.freq)
            print "baseband Freq is: %s" % (eng_notation.num_to_str(baseband_freq))
            dxc_freq, inverted = usrp.calc_dxc_freq(options.freq, baseband_freq,
            print "dxc Freq is: %s" % (eng_notation.num_to_str(dxc_freq))
            print "ddc Freq is: %s" % (eng_notation.num_to_str(ddc))
            self.u.set_rx_freq(n, ddc)
        input_rate = self.u.adc_freq() / self.u.decim_rate()       
        print "Using RX d'board %s" % (self.subdev0.side_and_name(),)
        print "Using RX d'board %s" % (self.subdev1.side_and_name(),)
        print "USB sample rate: %s" % (eng_notation.num_to_str(input_rate))
        print "Freq is set to: %s" % (eng_notation.num_to_str(options.freq))
        print "Recording time is: %ss" % (options.time)
        print "Mux value is: %x" % (mux_val0 & 65535)
        self.num_samples = options.nsamples
        #return (self, num_samples)

    def __del__(self):
    # Avoid weak reference error
        del self.subdev
    def write_file(self, file_num, file_size):
        # deinterleave two channels from FPGA
        self.di = gr.deinterleave(gr.sizeof_gr_complex)
        self.skiphead0 = gr.skiphead(gr.sizeof_gr_complex, 1000)
        self.skiphead1 = gr.skiphead(gr.sizeof_gr_complex, 1000)
        self.head0 = gr.head(gr.sizeof_gr_complex, file_size)
        self.head1 = gr.head(gr.sizeof_gr_complex, file_size)
        self.dst0 = gr.file_sink(gr.sizeof_gr_complex, ('moda%s' % file_num))
        self.dst1 = gr.file_sink(gr.sizeof_gr_complex, ('modb%s' % file_num))
        # wire up the head of the chain
        self.connect(self.u, self.di)
        self.connect((self.di,0), self.skiphead0, self.head0, self.dst0)
        self.connect((self.di,1), self.skiphead1, self.head1, self.dst1)
if __name__ == '__main__':
    total_time = 3
    t = 0
    n_s = 0
    tb = my_top_block()
    n_s = tb.num_samples  
        while t < total_time:
            t = t+1
            print "setup graph"
            tb.write_file(t, n_s)
            print "run graph"
            print "graph terminated"
            print "sleep on"
            print "sleep off"

    except KeyboardInterrupt:


reply via email to

[Prev in Thread] Current Thread [Next in Thread]