[Discuss-gnuradio] gnuradio tuner

#import uhd
import xmlrpclib
s = xmlrpclib.ServerProxy("http://localhost:30000/")
import numpy as np
#from uhd import libpyuhd as lib
from gnuradio import uhd
import scipy.signal as signal
import pyqtgraph as pg
import pyfftw
import time
import multiprocessing

pw=pg.plot()
import zmq

samples=363

socket_str = "tcp://127.0.0.1:5557"
k=np.arange(1800e6,1900e6,25e6)

buff=[k.size,]
def zmq_consumer():

context = zmq.Context()
results_receiver = context.socket(zmq.PULL)
results_receiver.connect(socket_str)
#results_receiver.setsockopt(zmq.SUBSCRIBE, '')
while True:
time1 = time.time()
result = np.array([])
for i,freqq in enumerate(k):

raw_data1= np.array([], dtype=np.complex64)

s.set_freq(float(freqq))
#time.sleep(0.005)
# pull in raw binary data

raw_data=results_receiver.recv()
float_list = np.frombuffer(raw_data, dtype="complex64")

res3 = pyfftw.builders.fft(float_list, overwrite_input=True, planner_effort='FFTW_ESTIMATE',
threads=multiprocessing.cpu_count())
b=res3()
result=np.hstack((result,b))

pw.plot(np.abs(result.ravel()), clear=True)
pg.QtGui.QApplication.processEvents()

# struct.unpack will be faster

print(time.time()-time1)

# start the receiver socket
zmq_consumer()#!/usr/bin/env python2
# -*- coding: utf-8 -*-
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Fri Jul 19 08:45:02 2019
##################################################

if __name__ == '__main__':
import ctypes
import sys
if sys.platform.startswith('linux'):
try:
x11 = ctypes.cdll.LoadLibrary('libX11.so')
x11.XInitThreads()
except:
print "Warning: failed to XInitThreads()"

from PyQt4 import Qt
from gnuradio import eng_notation
from gnuradio import gr
from gnuradio import uhd
from gnuradio import zeromq
from gnuradio.eng_option import eng_option
from gnuradio.filter import firdes
from gnuradio.qtgui import Range, RangeWidget
from optparse import OptionParser
import SimpleXMLRPCServer
import sys
import threading
import time
from gnuradio import qtgui

class top_block(gr.top_block, Qt.QWidget):

def __init__(self, freq=1000e6, gain=50):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)

self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())

##################################################
# Parameters
##################################################
self.freq = freq
self.gain = gain

##################################################
# Variables
##################################################
self.variable_qtgui_range_0 = variable_qtgui_range_0 = 900e6
self.samp_rate = samp_rate = 25e6

##################################################
# Blocks
##################################################
self.zeromq_push_sink_0 = zeromq.push_sink(gr.sizeof_gr_complex, 1, "tcp://127.0.0.1:5557", 20, False, -1)
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 30000), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
self.xmlrpc_server_0_thread = threading.Thread(target=self.xmlrpc_server_0.serve_forever)
self.xmlrpc_server_0_thread.daemon = True
self.xmlrpc_server_0_thread.start()
self._variable_qtgui_range_0_range = Range(400e6, 2400e6, 1, 900e6, 200)
self._variable_qtgui_range_0_win = RangeWidget(self._variable_qtgui_range_0_range, self.set_variable_qtgui_range_0, "variable_qtgui_range_0", "counter_slider", float)
self.top_grid_layout.addWidget(self._variable_qtgui_range_0_win)
self.uhd_usrp_source_0 = uhd.usrp_source(
",".join(('', "")),
uhd.stream_args(
cpu_format="fc32",
args='peak=0.003906',
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(freq, 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.uhd_usrp_source_0.set_antenna('RX2', 0)
self.uhd_usrp_source_0.set_bandwidth(25e6, 0)

##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.zeromq_push_sink_0, 0))

def closeEvent(self, event):
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.settings.setValue("geometry", self.saveGeometry())
event.accept()

def get_freq(self):
return self.freq

def set_freq(self, freq):
self.freq = freq
self.uhd_usrp_source_0.set_center_freq(self.freq, 0)

def get_gain(self):
return self.gain

def set_gain(self, gain):
self.gain = gain
self.uhd_usrp_source_0.set_gain(self.gain, 0)

def get_variable_qtgui_range_0(self):
return self.variable_qtgui_range_0

def set_variable_qtgui_range_0(self, variable_qtgui_range_0):
self.variable_qtgui_range_0 = variable_qtgui_range_0

def get_samp_rate(self):
return self.samp_rate

def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)

def argument_parser():
parser = OptionParser(usage="%prog: [options]", option_class=eng_option)
parser.add_option(
"", "--freq", dest="freq", type="eng_float", default=eng_notation.num_to_str(1000e6),
help="Set freq [default=%default]")
parser.add_option(
"", "--gain", dest="gain", type="eng_float", default=eng_notation.num_to_str(50),
help="Set gain [default=%default]")
return parser

def main(top_block_cls=top_block, options=None):
if options is None:
options, _ = argument_parser().parse_args()

from distutils.version import StrictVersion
if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"):
style = gr.prefs().get_string('qtgui', 'style', 'raster')
Qt.QApplication.setGraphicsSystem(style)
qapp = Qt.QApplication(sys.argv)

tb = top_block_cls(freq=options.freq, gain=options.gain)
tb.start()
tb.show()

def quitting():
tb.stop()
tb.wait()
qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting)
qapp.exec_()

if __name__ == '__main__':
main()

Hello. I want to make a broadband receiver based on the N 210
Work algorithm:
1. The exchange session between the board and the program is opened using ZMQ and also XMLRPS
2. Set the frequency from the external program and read the required number of samples.
3. Tuning frequency
4 Read samples.
But unfortunately I have problems reading samples. Since after frequency tuning I still read samples from the previous frequency.