[Discuss-gnuradio] initializing the baseband_freq in the fftsink2.fft_sink_c

[Markus Feldmann]

Hi all,

i only want to notify the Developers, that i found a Bug.
My gnuradio Version is,
SVN Sources from 2009 Feb 26.
The variable will not be initialized by variables i defined before.

The only thing what works is to initialze first the FFT sink Element
and after this change the <baseband_freq>.

Regards Markus

P.s.: I try to attach my Code.

#!/usr/bin/env python
# encoding: utf8
"""
Title:Mehrfrequentes Impulsmessverfahren mit FPGA-
gestützten SDR-(Software definded radio)-Komponenten.
Beschreibung: Mit Hilfe dieses Programmes soll ein
mehrfrequentes Impulsmessverfahren entwickelt werden,
womit Teilentladungen an Hochspannungsisolationen
nachgewiesen werden können.

"""

__title__='Mehrfrequentes Impulsmessverfahren'
__author__='Markus Feldmann'
__version__='Diplom WS08/09 Ver.:2009-02-27-01'
__license__='GPL'


from gnuradio import gr
from gnuradio.wxgui import fftsink2
from grc_gnuradio import usrp as grc_usrp
from grc_gnuradio import wxgui as grc_wxgui
from optparse import OptionParser
import wx
import time


class uebertragungschar_LF_RX(grc_wxgui.top_block_gui):

        def __init__(self, options):
                grc_wxgui.top_block_gui.__init__(self,
                   __title__+' - '+__author__+' - '+__version__)

                ##################################################
                # Parameters
                ##################################################
                self.sub_dev_side = options.sub_dev_side
                self.sub_dev_ant = options.sub_dev_ant
                self.usrp_freq = options.usrp_freq
                self.usrp_freq_min = options.usrp_freq_min
                self.usrp_freq_max = options.usrp_freq_max
                self.sample_rate = options.sample_rate

                ##################################################
                # Variables
                ##################################################
                self.middle_freq_fft_plot = self.usrp_freq
                self.gain_usrp_source = 0
                self.decimation_usrp_source = 64e6/self.sample_rate

                ##################################################
                # Controls
                ##################################################
                _usrp_freq_control = grc_wxgui.slider_horizontal_control(
                        window=self.GetWin(),
                        callback=self.set_usrp_freq,
                        label="Oszillatorfrequenz",
                        value=self.usrp_freq,
                        min=self.usrp_freq_min,
                        max=self.usrp_freq_max,
                        num_steps=290,
                        slider_length=1024,
                )
                self.Add(_usrp_freq_control)
                _fft_plot_sample_rate_control = grc_wxgui.drop_down_control(
                        window=self.GetWin(),
                        callback=self.set_sample_rate,
                        label="Sample Rate Throttle",
                        index=0,
                        choices=[250e3, 500e3, 1e6, 2e6, 4e6, 8e6, 16e6],
                        labels=[],
                )
                self.GridAdd(_fft_plot_sample_rate_control, 4, 1, 2, 1)
                _gain_usrp_source_control = grc_wxgui.slider_vertical_control(
                        window=self.GetWin(),
                        callback=self.set_gain_usrp_source,
                        label="Gain Usrp Source",
                        value=self.gain_usrp_source,
                        min=0,
                        max=20,
                        num_steps=100,
                        slider_length=200,
                )
                self.GridAdd(_gain_usrp_source_control, 4, 0, 2, 1)

                ##################################################
                # Blocks
                ##################################################
                self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex*1, 
self.sample_rate)
                self.usrp_simple_source_x = grc_usrp.simple_source_c(which=0, 
side=self.sub_dev_side,
                                                                             
rx_ant=self.sub_dev_ant)
                
self.usrp_simple_source_x.set_decim_rate(self.decimation_usrp_source)
                self.usrp_simple_source_x.set_frequency(self.usrp_freq, 
verbose=True)
                self.usrp_simple_source_x.set_gain(self.gain_usrp_source)
                self.wxgui_fftsink2 = fftsink2.fft_sink_c(
                        self.GetWin(),
                        baseband_freq = self.usrp_freq,
                        y_per_div = 10,
                        y_divs = 8,
                        ref_level = 60,
                        sample_rate = self.sample_rate,
                        fft_size = 1024,
                        fft_rate = 30,
                        average = True,
                        avg_alpha = None,
                        title = "FFT Plot",
                        size=(1024, 600),
                        peak_hold = False,
                )
                self.GridAdd(self.wxgui_fftsink2.win, 0, 0, 2, 4)

                ##################################################
                # Connections
                ##################################################
                self.connect((self.usrp_simple_source_x, 0), 
(self.gr_throttle_0, 0))
                self.connect((self.gr_throttle_0, 0), (self.wxgui_fftsink2, 0))
                
                ##################################################
                # FFT Plot Element does not show correct Baseband
                ##################################################
                self.set_usrp_freq(self.usrp_freq)

        def set_usrp_freq_min(self, usrp_freq_min):
                self.usrp_freq_min = usrp_freq_min

        def set_usrp_freq_max(self, usrp_freq_max):
                self.usrp_freq_max = usrp_freq_max

        def set_usrp_freq(self, freq):
                self.usrp_freq = freq
                self.usrp_simple_source_x.set_frequency(self.usrp_freq)
                self.wxgui_fftsink2.set_baseband_freq(self.usrp_freq)
                
        def get_usrp_freq(self):
                return self.usrp_freq

        def set_sample_rate(self, sample_rate):
                self.sample_rate = sample_rate
                self.set_decimation_usrp_source(sample_rate)
                self.wxgui_fftsink2.set_sample_rate(self.sample_rate)

        def set_gain_usrp_source(self, gain_usrp_source):
                self.gain_usrp_source = gain_usrp_source
                self.usrp_simple_source_x.set_gain(self.gain_usrp_source)

        def set_decimation_usrp_source(self, sample_rate):
                """
                The sample rate across the USB is determined by the 
interpolation or
                decimation rate programmed into the usrp.
                So you have to calculate deciamtion rate which you want to set 
up.

                On receive, USB sample rate = 64e6 / decimation_rate
                On transmit, USB sample rate = 128e6 / interpolation_rate

                """
                self.decimation_usrp_source = 64e6/sample_rate
                
self.usrp_simple_source_x.set_decim_rate(self.decimation_usrp_source)

if __name__ == '__main__':
        parser = OptionParser()
        parser.add_option("--subdev-side", dest="sub_dev_side", type="str", 
default='B',
                          help="select USRP side A or B")
        parser.add_option("--subdev-ant", dest="sub_dev_ant", type="str", 
default='RXB',
                          help="select USRP subdevice Antenna, for example RXA 
or RXB")
        parser.add_option("--usrp-freq", dest="usrp_freq", type="float", 
default=10e6)
        parser.add_option("--usrp-freq-min", dest="usrp_freq_min", 
type="float", default=0)
        parser.add_option("--usrp-freq-max", dest="usrp_freq_max", 
type="float", default=29e6)
        parser.add_option("--sample-rate", dest="sample_rate", type="float", 
default=250e3)
        (options, args) = parser.parse_args()   
        tb = uebertragungschar_LF_RX(options)
        tb.Run()