def __init__(self, encoder_list_0, input_size, output_size):
gr.hier_block2.__init__(
self, "Threaded Encoder",
gr.io_signature(1, 1, input_size*1),
gr.io_signature(1, 1, output_size*1))
self.encoder_list_0 = encoder_list_0
self.fec_deinterleave_0 = blocks.deinterleave(input_size,
fec.get_encoder_input_size(encoder_list_0[0]))
self.generic_encoders_0 = [];
for i in range(len(encoder_list_0)):
self.generic_encoders_0.append(fec.encoder(encoder_list_0[i],
input_size, output_size))
self.fec_interleave_0 = blocks.interleave(output_size,
fec.get_encoder_output_size(encoder_list_0[0]))
for i in range(len(encoder_list_0)):
self.connect((self.fec_deinterleave_0, i), (self.generic_encoders_0[i], 0))
for i in range(len(encoder_list_0)):
self.connect((self.generic_encoders_0[i], 0), (self.fec_interleave_0, i))
self.connect((self, 0), (self.fec_deinterleave_0, 0))
self.connect((self.fec_interleave_0, 0), (self, 0))
def __init__(self,
encoder_obj_list,
puncpat=None,
lentagname=None,
mtu=1500):
gr.hier_block2.__init__(self, "extended_tagged_encoder",
gr.io_signature(1, 1, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_char))
self.blocks = []
self.puncpat = puncpat
# If it's a list of encoders, take the first one, unless it's
# a list of lists of encoders.
if (type(encoder_obj_list) == list):
# This block doesn't handle parallelism of > 1
# We could just grab encoder [0][0], but we don't want to encourage this.
if (type(encoder_obj_list[0]) == list):
gr.log.info(
"fec.extended_tagged_encoder: Parallelism must be 0 or 1.")
raise AttributeError
encoder_obj = encoder_obj_list[0]
# Otherwise, just take it as is
else:
encoder_obj = encoder_obj_list
# If lentagname is None, fall back to using the non tagged
# stream version
if type(lentagname) == str:
if (lentagname.lower() == 'none'):
lentagname = None
if fec.get_encoder_input_conversion(encoder_obj) == "pack":
self.blocks.append(blocks.pack_k_bits_bb(8))
if (not lentagname):
self.blocks.append(
fec.encoder(encoder_obj, gr.sizeof_char, gr.sizeof_char))
else:
self.blocks.append(
fec.tagged_encoder(encoder_obj, gr.sizeof_char, gr.sizeof_char,
lentagname, mtu))
if self.puncpat != '11':
self.blocks.append(
fec.puncture_bb(len(puncpat), read_bitlist(puncpat), 0))
# Connect the input to the encoder and the output to the
# puncture if used or the encoder if not.
self.connect((self, 0), (self.blocks[0], 0))
self.connect((self.blocks[-1], 0), (self, 0))
# If using the puncture block, add it into the flowgraph after
# the encoder.
for i in range(len(self.blocks) - 1):
self.connect((self.blocks[i], 0), (self.blocks[i + 1], 0))
def __init__(self, encoder_obj_list, puncpat=None, lentagname=None):
gr.hier_block2.__init__(self, "extended_tagged_encoder",
gr.io_signature(1, 1, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_char))
self.blocks=[]
self.puncpat=puncpat
# If it's a list of encoders, take the first one, unless it's
# a list of lists of encoders.
if(type(encoder_obj_list) == list):
# This block doesn't handle parallelism of > 1
# We could just grab encoder [0][0], but we don't want to encourage this.
if(type(encoder_obj_list[0]) == list):
gr.log.info("fec.extended_tagged_encoder: Parallelism must be 0 or 1.")
raise AttributeError
encoder_obj = encoder_obj_list[0]
# Otherwise, just take it as is
else:
encoder_obj = encoder_obj_list
# If lentagname is None, fall back to using the non tagged
# stream version
if type(lentagname) == str:
if(lentagname.lower() == 'none'):
lentagname = None
if fec.get_encoder_input_conversion(encoder_obj) == "pack":
self.blocks.append(blocks.pack_k_bits_bb(8))
if(not lentagname):
self.blocks.append(fec.encoder(encoder_obj,
gr.sizeof_char,
gr.sizeof_char))
else:
self.blocks.append(fec.tagged_encoder(encoder_obj,
gr.sizeof_char,
gr.sizeof_char,
lentagname))
if self.puncpat != '11':
self.blocks.append(fec.puncture_bb(len(puncpat), read_bitlist(puncpat), 0))
# Connect the input to the encoder and the output to the
# puncture if used or the encoder if not.
self.connect((self, 0), (self.blocks[0], 0));
self.connect((self.blocks[-1], 0), (self, 0));
# If using the puncture block, add it into the flowgraph after
# the encoder.
for i in range(len(self.blocks) - 1):
self.connect((self.blocks[i], 0), (self.blocks[i+1], 0));
def __init__(self, encoder_obj_list, threading, puncpat=None):
gr.hier_block2.__init__(self, "extended_encoder",
gr.io_signature(1, 1, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_char))
self.blocks = []
self.puncpat = puncpat
if (type(encoder_obj_list) == list):
if (type(encoder_obj_list[0]) == list):
gr.log.info("fec.extended_encoder: Parallelism must be 1.")
raise AttributeError
else:
# If it has parallelism of 0, force it into a list of 1
encoder_obj_list = [
encoder_obj_list,
]
if fec.get_encoder_input_conversion(encoder_obj_list[0]) == "pack":
self.blocks.append(blocks.pack_k_bits_bb(8))
if threading == 'capillary':
self.blocks.append(
capillary_threaded_encoder(encoder_obj_list, gr.sizeof_char,
gr.sizeof_char))
elif threading == 'ordinary':
self.blocks.append(
threaded_encoder(encoder_obj_list, gr.sizeof_char,
gr.sizeof_char))
else:
self.blocks.append(
fec.encoder(encoder_obj_list[0], gr.sizeof_char,
gr.sizeof_char))
if fec.get_encoder_output_conversion(
encoder_obj_list[0]) == "packed_bits":
self.blocks.append(blocks.packed_to_unpacked_bb(
1, gr.GR_MSB_FIRST))
if self.puncpat != '11':
self.blocks.append(
fec.puncture_bb(len(puncpat), read_bitlist(puncpat), 0))
# Connect the input to the encoder and the output to the
# puncture if used or the encoder if not.
self.connect((self, 0), (self.blocks[0], 0))
self.connect((self.blocks[-1], 0), (self, 0))
# If using the puncture block, add it into the flowgraph after
# the encoder.
for i in range(len(self.blocks) - 1):
self.connect((self.blocks[i], 0), (self.blocks[i + 1], 0))
def __init__(self, encoder_obj_list, threading, puncpat=None):
gr.hier_block2.__init__(self, "extended_encoder",
gr.io_signature(1, 1, gr.sizeof_char),
gr.io_signature(1, 1, gr.sizeof_char))
self.blocks=[]
self.puncpat=puncpat
if(type(encoder_obj_list) == list):
if(type(encoder_obj_list[0]) == list):
gr.log.info("fec.extended_encoder: Parallelism must be 1.")
raise AttributeError
else:
# If it has parallelism of 0, force it into a list of 1
encoder_obj_list = [encoder_obj_list,]
if fec.get_encoder_input_conversion(encoder_obj_list[0]) == "pack":
self.blocks.append(blocks.pack_k_bits_bb(8))
if threading == 'capillary':
self.blocks.append(capillary_threaded_encoder(encoder_obj_list,
gr.sizeof_char,
gr.sizeof_char))
elif threading == 'ordinary':
self.blocks.append(threaded_encoder(encoder_obj_list,
gr.sizeof_char,
gr.sizeof_char))
else:
self.blocks.append(fec.encoder(encoder_obj_list[0],
gr.sizeof_char,
gr.sizeof_char))
if fec.get_encoder_output_conversion(encoder_obj_list[0]) == "packed_bits":
self.blocks.append(blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST))
if self.puncpat != '11':
self.blocks.append(fec.puncture_bb(len(puncpat), read_bitlist(puncpat), 0))
# Connect the input to the encoder and the output to the
# puncture if used or the encoder if not.
self.connect((self, 0), (self.blocks[0], 0));
self.connect((self.blocks[-1], 0), (self, 0));
# If using the puncture block, add it into the flowgraph after
# the encoder.
for i in range(len(self.blocks) - 1):
self.connect((self.blocks[i], 0), (self.blocks[i+1], 0));
def __init__(self, encoder_list_0, input_size=gr.sizeof_char, output_size=gr.sizeof_char):
gr.hier_block2.__init__(self, "Capillary Threaded Encoder",
gr.io_signature(1, 1, input_size),
gr.io_signature(1, 1, output_size))
self.encoder_list_0 = encoder_list_0
check = math.log10(len(self.encoder_list_0)) / math.log10(2.0)
if(abs(check - int(check)) > 0.0):
gr.log.info("fec.capillary_threaded_encoder: number of encoders must be a power of 2.")
raise AttributeError
self.deinterleaves_0 = [];
for i in range(int(math.log(len(encoder_list_0), 2))):
for j in range(int(math.pow(2, i))):
self.deinterleaves_0.append(blocks.deinterleave(input_size,
fec.get_encoder_input_size(encoder_list_0[0])))
self.generic_encoders_0 = [];
for i in range(len(encoder_list_0)):
self.generic_encoders_0.append(fec.encoder(encoder_list_0[i],
input_size, output_size))
self.interleaves_0 = [];
for i in range(int(math.log(len(encoder_list_0), 2))):
for j in range(int(math.pow(2, i))):
self.interleaves_0.append(blocks.interleave(output_size,
fec.get_encoder_output_size(encoder_list_0[0])))
rootcount = 0;
branchcount = 1;
for i in range(int(math.log(len(encoder_list_0), 2)) - 1):
for j in range(int(math.pow(2, i))):
self.connect((self.deinterleaves_0[rootcount], 0), (self.deinterleaves_0[branchcount], 0))
self.connect((self.deinterleaves_0[rootcount], 1), (self.deinterleaves_0[branchcount + 1], 0))
rootcount += 1;
branchcount += 2;
codercount = 0;
for i in range(len(encoder_list_0)/2):
self.connect((self.deinterleaves_0[rootcount], 0), (self.generic_encoders_0[codercount], 0))
self.connect((self.deinterleaves_0[rootcount], 1), (self.generic_encoders_0[codercount + 1], 0))
rootcount += 1;
codercount += 2;
rootcount = 0;
branchcount = 1;
for i in range(int(math.log(len(encoder_list_0), 2)) - 1):
for j in range(int(math.pow(2, i))):
self.connect((self.interleaves_0[branchcount], 0), (self.interleaves_0[rootcount], 0))
self.connect((self.interleaves_0[branchcount + 1], 0), (self.interleaves_0[rootcount], 1))
rootcount += 1;
branchcount += 2;
codercount = 0;
for i in range(len(encoder_list_0)/2):
self.connect((self.generic_encoders_0[codercount], 0), (self.interleaves_0[rootcount], 0))
self.connect((self.generic_encoders_0[codercount + 1], 0), (self.interleaves_0[rootcount], 1))
rootcount += 1;
codercount += 2;
if((len(self.encoder_list_0)) > 1):
self.connect((self, 0), (self.deinterleaves_0[0], 0))
self.connect((self.interleaves_0[0], 0), (self, 0))
else:
self.connect((self, 0), (self.generic_encoders_0[0], 0))
self.connect((self.generic_encoders_0[0], 0), (self, 0))
def __init__(self,
encoder_list_0,
input_size=gr.sizeof_char,
output_size=gr.sizeof_char):
gr.hier_block2.__init__(self, "Capillary Threaded Encoder",
gr.io_signature(1, 1, input_size),
gr.io_signature(1, 1, output_size))
self.encoder_list_0 = encoder_list_0
check = math.log10(len(self.encoder_list_0)) / math.log10(2.0)
if (abs(check - int(check)) > 0.0):
gr.log.info(
"fec.capillary_threaded_encoder: number of encoders must be a power of 2."
)
raise AttributeError
self.deinterleaves_0 = []
for i in range(int(math.log(len(encoder_list_0), 2))):
for j in range(int(math.pow(2, i))):
self.deinterleaves_0.append(
blocks.deinterleave(
input_size,
fec.get_encoder_input_size(encoder_list_0[0])))
self.generic_encoders_0 = []
for i in range(len(encoder_list_0)):
self.generic_encoders_0.append(
fec.encoder(encoder_list_0[i], input_size, output_size))
self.interleaves_0 = []
for i in range(int(math.log(len(encoder_list_0), 2))):
for j in range(int(math.pow(2, i))):
self.interleaves_0.append(
blocks.interleave(
output_size,
fec.get_encoder_output_size(encoder_list_0[0])))
rootcount = 0
branchcount = 1
for i in range(int(math.log(len(encoder_list_0), 2)) - 1):
for j in range(int(math.pow(2, i))):
self.connect((self.deinterleaves_0[rootcount], 0),
(self.deinterleaves_0[branchcount], 0))
self.connect((self.deinterleaves_0[rootcount], 1),
(self.deinterleaves_0[branchcount + 1], 0))
rootcount += 1
branchcount += 2
codercount = 0
for i in range(len(encoder_list_0) / 2):
self.connect((self.deinterleaves_0[rootcount], 0),
(self.generic_encoders_0[codercount], 0))
self.connect((self.deinterleaves_0[rootcount], 1),
(self.generic_encoders_0[codercount + 1], 0))
rootcount += 1
codercount += 2
rootcount = 0
branchcount = 1
for i in range(int(math.log(len(encoder_list_0), 2)) - 1):
for j in range(int(math.pow(2, i))):
self.connect((self.interleaves_0[branchcount], 0),
(self.interleaves_0[rootcount], 0))
self.connect((self.interleaves_0[branchcount + 1], 0),
(self.interleaves_0[rootcount], 1))
rootcount += 1
branchcount += 2
codercount = 0
for i in range(len(encoder_list_0) / 2):
self.connect((self.generic_encoders_0[codercount], 0),
(self.interleaves_0[rootcount], 0))
self.connect((self.generic_encoders_0[codercount + 1], 0),
(self.interleaves_0[rootcount], 1))
rootcount += 1
codercount += 2
if ((len(self.encoder_list_0)) > 1):
self.connect((self, 0), (self.deinterleaves_0[0], 0))
self.connect((self.interleaves_0[0], 0), (self, 0))
else:
self.connect((self, 0), (self.generic_encoders_0[0], 0))
self.connect((self.generic_encoders_0[0], 0), (self, 0))
