def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):
"""
Selector constructor.
Args:
item_size: the size of the gr data stream in bytes
num_inputs: the number of inputs (integer)
num_outputs: the number of outputs (integer)
input_index: the index for the source data
output_index: the index for the destination data
"""
gr.hier_block2.__init__(
self, 'selector',
gr.io_signature(num_inputs, num_inputs, item_size),
gr.io_signature(num_outputs, num_outputs, item_size),
)
#terminator blocks for unused inputs and outputs
self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)]
self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)]
self.copy = blocks.copy(item_size)
#connections
for i in range(num_inputs): self.connect((self, i), self.input_terminators[i])
for i in range(num_outputs): self.connect(blocks.null_source(item_size),
self.output_terminators[i], (self, i))
self.item_size = item_size
self.input_index = input_index
self.output_index = output_index
self.num_inputs = num_inputs
self.num_outputs = num_outputs
self._connect_current()
def __init__(self):
gr.top_block.__init__(self, "Affinity Set Test")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
vec_len = 1
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_oc_complex*vec_len, samp_rate)
self.blocks_null_source_0 = blocks.null_source(gr.sizeof_oc_complex*vec_len)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_oc_complex*vec_len)
self.filter_filt_0 = filter.fir_filter_ccc(1, 40000*[0.2+0.3j,])
self.filter_filt_1 = filter.fir_filter_ccc(1, 40000*[0.2+0.3j,])
self.filter_filt_0.set_processor_affinity([0,])
self.filter_filt_1.set_processor_affinity([0,1])
##################################################
# Connections
##################################################
self.connect((self.blocks_null_source_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.filter_filt_0, 0))
self.connect((self.filter_filt_0, 0), (self.filter_filt_1, 0))
self.connect((self.filter_filt_1, 0), (self.blocks_null_sink_0, 0))
def __init__(self, nstages, ntaps=256):
"""
Create a pipeline of nstages of filter.fir_filter_fff's connected in serial
terminating in a blocks.null_sink.
"""
gr.hier_block2.__init__(self, "pipeline",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0, 0, 0))
taps = ntaps*[1.0/ntaps]
upstream = self
for i in range(nstages):
op = filter.fir_filter_fff(1, taps)
self.connect(upstream, op)
upstream = op
self.connect(upstream, blocks.null_sink(gr.sizeof_float))
def __init__(self, packet_sink=None):
#initialize hier2
gr.hier_block2.__init__(
self,
"ofdm_mod",
gr.io_signature(1, 1, packet_sink._hb.input_signature().sizeof_stream_item(0)), # Input signature
gr.io_signature(1, 1, self._item_size_out) # Output signature
)
#create blocks
msg_source = blocks.message_source(self._item_size_out, DEFAULT_MSGQ_LIMIT)
self._msgq_out = msg_source.msgq()
#connect
self.connect(self, packet_sink)
self.connect(msg_source, self)
if packet_sink._hb.output_signature().sizeof_stream_item(0):
self.connect(packet_sink,
blocks.null_sink(packet_sink._hb.output_signature().sizeof_stream_item(0)))
def __init__(self, N, op,
isizeof=gr.sizeof_oc_complex,
osizeof=gr.sizeof_oc_complex,
nsrcs=1, nsnks=1):
gr.top_block.__init__(self, "helper")
self.op = op
self.srcs = []
self.snks = []
self.head = blocks.head(isizeof, N)
for n in xrange(nsrcs):
self.srcs.append(blocks.null_source(isizeof))
for n in xrange(nsnks):
self.snks.append(blocks.null_sink(osizeof))
self.connect(self.srcs[0], self.head, (self.op,0))
for n in xrange(1, nsrcs):
self.connect(self.srcs[n], (self.op,n))
for n in xrange(nsnks):
self.connect((self.op,n), self.snks[n])
