def __init__(self, access_code='', threshold=-1, callback=None):
"""
packet_demod constructor.
Args:
access_code: AKA sync vector
threshold: detect access_code with up to threshold bits wrong (0 -> use default)
callback: a function of args: ok, payload
"""
#access code
if not access_code: #get access code
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
self._access_code = access_code
#threshold
if threshold < 0: threshold = DEFAULT_THRESHOLD
self._threshold = threshold
#blocks
msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT) #holds packets from the PHY
correlator = digital.correlate_access_code_bb(self._access_code, self._threshold)
framer_sink = digital.framer_sink_1(msgq)
#initialize hier2
gr.hier_block2.__init__(
self,
"packet_decoder",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(0, 0, 0) # Output signature
)
#connect
self.connect(self, correlator, framer_sink)
#start thread
_packet_decoder_thread(msgq, callback)
def __init__(self, samples_per_symbol, bits_per_symbol, access_code='', pad_for_usrp=True):
"""
packet_mod constructor.
Args:
samples_per_symbol: number of samples per symbol
bits_per_symbol: number of bits per symbol
access_code: AKA sync vector
pad_for_usrp: If true, packets are padded such that they end up a multiple of 128 samples
payload_length: number of bytes in a data-stream slice
"""
#setup parameters
self._samples_per_symbol = samples_per_symbol
self._bits_per_symbol = bits_per_symbol
self._pad_for_usrp = pad_for_usrp
if not access_code: #get access code
access_code = packet_utils.default_access_code
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "Invalid access_code %r. Must be string of 1's and 0's" % (access_code,)
self._access_code = access_code
self._pad_for_usrp = pad_for_usrp
#create blocks
msg_source = blocks.message_source(gr.sizeof_char, DEFAULT_MSGQ_LIMIT)
self._msgq_out = msg_source.msgq()
#initialize hier2
gr.hier_block2.__init__(
self,
"packet_encoder",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_char) # Output signature
)
#connect
self.connect(msg_source, self)
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.hier_block2.__init__(self,
"hier_block_with_message_output",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self.message_port_register_hier_out("test")
self.block = block_with_message_input()
self.msg_connect(weakref.proxy(self), "test", self.block, "test")
def __init__(self):
gr.hier_block2.__init__(self, "s",
gr.io_signature(2, 2, gr.sizeof_oc_complex),
gr.io_signature(1, 1, gr.sizeof_oc_complex))
conj = blocks.conjugate_cc()
mult = blocks.multiply_cc()
self.connect((self,0), (mult,0))
self.connect((self,1), conj, (mult,1))
self.connect(mult, self)
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, packet_source=None, payload_length=0):
if not payload_length: #get payload length
payload_length = DEFAULT_PAYLOAD_LEN
if payload_length%self._item_size_in != 0: #verify that packet length is a multiple of the stream size
raise ValueError, 'The payload length: "%d" is not a mutiple of the stream size: "%d".'%(payload_length, self._item_size_in)
#initialize hier2
gr.hier_block2.__init__(
self,
"ofdm_mod",
gr.io_signature(1, 1, self._item_size_in), # Input signature
gr.io_signature(1, 1, packet_source._hb.output_signature().sizeof_stream_item(0)) # Output signature
)
#create blocks
msgq = gr.msg_queue(DEFAULT_MSGQ_LIMIT)
msg_sink = blocks.message_sink(self._item_size_in, msgq, False) #False -> blocking
#connect
self.connect(self, msg_sink)
self.connect(packet_source, self)
#start thread
_packet_encoder_thread(msgq, payload_length, packet_source.send_pkt)
def __init__(self, type='BER', win_size=default_win_size, bits_per_symbol=2):
"""
Error rate constructor.
Args:
type: a string 'BER' or 'SER'
win_size: the number of samples to calculate over
bits_per_symbol: the number of information bits per symbol (BER only)
"""
#init
gr.hier_block2.__init__(
self, 'error_rate',
gr.io_signature(2, 2, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_float),
)
assert type in ('BER', 'SER')
self._max_samples = win_size
self._bits_per_symbol = bits_per_symbol
#setup message queue
msg_source = blocks.message_source(gr.sizeof_float, 1)
self._msgq_source = msg_source.msgq()
msgq_sink = gr.msg_queue(2)
msg_sink = blocks.message_sink(gr.sizeof_char, msgq_sink, False) #False -> blocking
inter = blocks.interleave(gr.sizeof_char)
#start thread
self._num_errs = 0
self._err_index = 0
self._num_samps = 0
self._err_array = numpy.zeros(self._max_samples, numpy.int8)
if type == 'BER':
input_watcher(msgq_sink, self._handler_ber)
elif type == 'SER':
input_watcher(msgq_sink, self._handler_ser)
#connect
self.connect(msg_source, self)
self.connect((self, 0), (inter, 0))
self.connect((self, 1), (inter, 1))
self.connect(inter, msg_sink)
def __init__(self, itemsize, addr, port, server=False):
# init hier block
gr.hier_block2.__init__(self, "tcp_sink", gr.io_signature(1, 1, itemsize), gr.io_signature(0, 0, 0))
fd = _get_sock_fd(addr, port, server)
self.connect(self, blocks.file_descriptor_sink(itemsize, fd))
def __init__(self, itemsize, addr, port, server=True):
# init hier block
gr.hier_block2.__init__(self, "tcp_source", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, itemsize))
fd = _get_sock_fd(addr, port, server)
self.connect(blocks.file_descriptor_source(itemsize, fd), self)
