def test_add_f32(self):
tb = gr.flowgraph()
input_data = list(range(1000))
expected_output = [2 * x for x in input_data]
src0 = blocks.vector_source_f(input_data, False)
src1 = blocks.vector_source_f(input_data, False)
adder = add_2_f32_1_f32()
copy_blks = []
nblocks = 1
bufsize = 1024 * 1024
tb.connect((src0, 0), (adder, 0)).set_custom_buffer(
gr.buffer_cuda_sm_properties.make(
gr.buffer_cuda_sm_type.H2D).set_min_buffer_size(bufsize))
tb.connect((src1, 0), (adder, 1)).set_custom_buffer(
gr.buffer_cuda_sm_properties.make(
gr.buffer_cuda_sm_type.H2D).set_min_buffer_size(bufsize))
last_blk = (adder, 0)
for ii in range(nblocks):
copy_blks.append(copy_f32())
tb.connect(last_blk, (copy_blks[ii], 0)).set_custom_buffer(
gr.buffer_cuda_sm_properties.make(
gr.buffer_cuda_sm_type.D2D).set_min_buffer_size(bufsize))
last_blk = (copy_blks[ii], 0)
sink = blocks.vector_sink_f()
tb.connect(last_blk, (sink, 0)).set_custom_buffer(
gr.buffer_cuda_sm_properties.make(
gr.buffer_cuda_sm_type.D2H).set_min_buffer_size(bufsize))
# tb.connect(adder, sink).set_custom_buffer(gr.buffer_cuda_sm_properties.make(gr.buffer_cuda_sm_type.D2H))
tb.run()
self.assertEqual(sink.data(), expected_output)
def test_optional_absent(self):
tb = gr.flowgraph()
src0 = blocks.vector_source_f([1, 3, 5, 7, 9], False)
src1 = blocks.vector_source_f([0, 2, 4, 6, 8], False)
adder = add_optional()
sink = blocks.vector_sink_f()
tb.connect((src0, 0), (adder, 0))
tb.connect((src1, 0), (adder, 1))
tb.connect(adder, sink)
tb.run()
self.assertEqual(sink.data(), [1, 5, 9, 13, 17])
def setUp(self):
self.tb = gr.flowgraph()
self.freqs = [110., -513., 203., -230, 121]
# Number of channels to channelize.
self.M = len(self.freqs)
# Number of samples to use.
self.N = 1000
# Baseband sampling rate.
self.fs = 5000
# Input samp rate to channelizer.
self.ifs = self.M * self.fs
self.taps = filter.firdes.low_pass_2(
1, self.ifs, self.fs / 2, self.fs / 10,
attenuation_dB=80,
window=fft.window.WIN_BLACKMAN_hARRIS)
self.Ntest = 50
def setUp(self):
self.tb = gr.flowgraph()
self.rt = gr.runtime()
def flowgraph_create(self, **kwargs):
self.fgs[kwargs['fg_name']] = gr.flowgraph(kwargs['fg_name'])
# self.fgs[fg_name] = gr.flowgraph(fg_name)
return {'status': 0}
def setUp(self):
os.environ['GR_CONF_CONTROLPORT_ON'] = 'False'
self.tb = gr.flowgraph()
self.rt = gr.runtime()
from gnuradio.pyqtgraph.numpy import *
import threading, time
app = pg.mkQApp('DockArea Example')
win = QtGui.QMainWindow()
area = DockArea()
win.setCentralWidget(area)
win.resize(1000,500)
win.setWindowTitle('pyqtgraph example: dockarea')
samp_rate = 2000000
freq = 751000000
gain = 40
fg = gr.flowgraph()
src = soapy.hackrf_source_c(samp_rate, freq, gain, vga=30.0, amp=True)
# src = analog.sig_source_f(samp_rate, analog.waveform_t.cos, 12, 1.0)
# snk = pg_plot_widget_f(100000, 'hello world')
snk = pg_time_sink_c('hello world', 100000, 1)
# snk2 = pg_time_sink_f('hello world 2', 100000)
fg.connect(src, 0, snk, 0)
d1 = Dock('a')
area.addDock(d1,'top')
d1.addWidget(snk.widget())
d2 = Dock('console')
namespace = {'pg': pg, 'src': src }
c = pyqtgraph.console.ConsoleWidget(namespace=namespace)
def setUp(self):
random.seed(0)
self.tb = gr.flowgraph()
# An example of distributing a flowgraph across remote nodes
# These nodes could be containerized and/or live on remote hosts
nsamples = 1000
# input_data = [x%256 for x in list(range(nsamples))]
input_data = list(range(nsamples))
# Blocks are created locally, but will be replicated on the remote host
src = blocks.vector_source_f(input_data, False)
cp1 = streamops.copy()
mc = math.multiply_const_ff(1.0)
cp2 = streamops.copy()
snk = blocks.vector_sink_f()
fg1 = gr.flowgraph("FG On Local Host")
fg1.connect([src, cp1, mc, cp2, snk])
with distributed.runtime(
os.path.join(os.path.dirname(__file__), 'test_config.yml')) as rt1:
# There are 2 remote hosts defined in the config yml
# We assign groups of blocks where we want them to go
rt1.assign_blocks("newsched1", [src, cp1, mc])
rt1.assign_blocks("newsched2", [cp2, snk])
rt1.initialize(fg1)
# These calls on the local block are serialized to the remote block
# This in effect means the local blocks are acting as proxy blocks
mc.set_k(2.0)
print(mc.k())
