[Discuss-gnuradio] unknown peak in the FFT-Plot Sink

[Markus Feldmann]

Hi All,

in all the examples and in my own gnuradio Programm, there
is an unknown Peak in the FFT-Plot sink.

Here is the Screenshot:
http://img257.imageshack.us/img257/8017/nochstrender.jpg

How to avoid this ?
Wherefrom does this come ?
I attach my Program to this mail, but i think it is still ok.

I need this to measure the power of the noise.

Further on you see the noise has a wave form always in
the middle of the FFT-Plot, still when i watch another
spectrum. In the gnuraio example from Eric Blossom this
doesn't appear, but this example only use a sin-signal-source
not a usrp-source.

How to avoid this ?
I tried to change the decimation and the sample Rate,
but doesn't solved this.

Regards Markus

#!/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-03-09-01'
__license__='GPL'


from gnuradio import gr
from gnuradio import usrp
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
from usrpm import usrp_dbid
import sys
import time
import wx


class uebertragungschar_LF_RX(grc_wxgui.top_block_gui):

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

                ##################################################
                # DEBUG
                ##################################################
                self.debug = options.debug
                if self.debug is True:
                        print 'DEBUG: start debug modus.'
        
                        
                ##################################################
                # Parameters
                ##################################################
                self.usrp_freq = options.usrp_freq
                self.usrp_freq_min = options.usrp_freq_min
                self.usrp_freq_max = options.usrp_freq_max
                self.decim = options.usrp_decim

                ##################################################
                # Variables
                ##################################################
                self.middle_freq_fft_plot = self.usrp_freq
                self.gain_usrp_source = 0
                """
                The Argument options.dev must be converted into the intern
                ID, so that we can select the device. The ID will be saved
                in this variable:
                """
                self.selected_device = None

                ##################################################
                # Blocks
                ##################################################
#               self.gr_complex_to_real_0 = gr.complex_to_real(1)
                self.usrp_source = usrp.source_c(which=0, decim_rate=self.decim)

                ##################################################
                # Further Variables
                ##################################################
                """
                Because we do not know where the LF_RX(for example) is placed, 
we have
                to search for it and select it.
                First we have to get the intern ID. For example we search after 
LF_RX
                and get an ID like (1, 0), this means the LF_RX is placed onto
                side B and there at RXB.
                (0, 0)-->side A/RXA
                (0, 1)-->side A/TXA
                (1, 0)-->side B/RXB
                (1, 1)-->side B/TXB
                After we found the device and got the intern ID, we select it.
                """
                if options.device=='LFRX': 
                        self.device_found = usrp.pick_subdev(self.usrp_source, 
(usrp_dbid.LF_RX,))
                        if self.debug: print 'DEBUG: <self.device_found> is 
',self.device_found
                        self.selected_device = 
usrp.selected_subdev(self.usrp_source, self.device_found)
                        if self.debug: print 'DEBUG: <self.selected_device> is 
',self.selected_device
                elif options.device=='BasicRX':
                        self.device_found = usrp.pick_subdev(self.usrp_source, 
(usrp_dbid.BASIC_RX,))
                        if self.debug: print 'DEBUG: <self.device_found> is 
',self.device_found
                        self.selected_device = 
usrp.selected_subdev(self.usrp_source, self.device_found)
                        if self.debug: print 'DEBUG: <self.selected_device> is 
',self.selected_device
                else:
                        print 'ERROR: You selected an illegal device named: 
',options.device
                        parser.print_help()
                        sys.exit(1)
                self.mux_value = 
usrp.determine_rx_mux_value(self.usrp_source,self.device_found)
                if self.debug: print 'DEBUG: <self.mux_value>',self.mux_value
                """
                We have to calculate the fftp_rate which is equal to the 
usrp_rate.
                At adc_rate=64MS/s and decim=250 we get an usrp_rate of 256 kS/s
                """
                self.usrp_rate = (self.usrp_source.adc_rate() / self.decim ) / 2
                if self.debug: print 'DEBUG: <self.decim> is ',self.decim
                if self.debug: print 'DEBUG: <self.usrp_source.adx_rate> is 
',self.usrp_source.adc_rate()
                if self.debug: print 'DEBUG: <self.usrp_rate> is 
',self.usrp_rate

                ##################################################
                # Futher Blocks
                ##################################################
#               self.gr_throttle_0 = gr.throttle(gr.sizeof_float*1, 
self.usrp_rate)
                self.usrp_source.set_mux(self.mux_value)
                self.wxgui_fftsink2 = fftsink2.fft_sink_c(
                        self.GetWin(),
                        baseband_freq = self.usrp_freq,
                        y_per_div = 10,
                        y_divs = 8,
                        ref_level = 0,
                        sample_rate = self.usrp_rate,
                        fft_size = 512*2,
                        #fft_rate = 30,
                        ref_scale=11885000.0,# 11885000.0 oder 32768.0
                        average = True,
                        avg_alpha = None,
                        title = "FFT Plot",
                        size=(1024, 600),
                        peak_hold = False,
                )
                self.GridAdd(self.wxgui_fftsink2.win, 0, 0, 2, 4)

                ##################################################
                # Controls
                ##################################################
                self._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=1e3,
                        slider_length=1024,
                )
                self.Add(self._usrp_freq_control)
                self._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(self._gain_usrp_source_control, 4, 0, 2, 1)

                ##################################################
                # Connections
                ##################################################
                self.connect((self.usrp_source, 0), (self.wxgui_fftsink2, 0))

                #################################################
                # Set Inital Value
                #################################################
                self.set_usrp_freq(self.usrp_freq)
                self.set_gain_usrp_source(0)
                self._gain_usrp_source_control.set_value(0)

        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
                """
                The usrp.tune command takes 4 arguments, first ist your <Usrp 
Source>
                the second is Digital Down Converter Number mostly 0, followed 
by the
                the selected device(for example our LFRX) ending with the 
target frequency
                we are interesting in.
                """
                usrp.tune(self.usrp_source, 0, self.selected_device, 
self.usrp_freq)
                self.wxgui_fftsink2.set_baseband_freq(self.usrp_freq)
                
        def get_usrp_freq(self):
                return self.usrp_freq

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

if __name__ == '__main__':
        parser = OptionParser()
        parser.add_option("-e","--dev", dest="device", type="str", 
default='LFRX',
                          help="Replace <DEVICE> by 'LFRX' or 'BasicRX'.")      
        parser.add_option("-c","--decim", dest="usrp_decim", type="int", 
default='250',
                          help="Replace <USRP_DECIM> by the desired decimation 
Rate of the USRP(default is 250).")
        parser.add_option("-f","--usrp-freq", dest="usrp_freq", type="float", 
default=1e6)
        parser.add_option("-u","--usrp-freq-min", dest="usrp_freq_min", 
type="float", default=500.0e3)
        parser.add_option("-o","--usrp-freq-max", dest="usrp_freq_max", 
type="float", default=10e6)
        parser.add_option("-d", "--debug", action="store_true", default=False,
                          help="Start the debug modus.")
        (options, args) = parser.parse_args()   
        tb = uebertragungschar_LF_RX(options)
        tb.Run()