Esempio n. 1
0
    def __init__(self):
        gr.top_block.__init__(self)

        ##################################################
        # Variables
        ##################################################
        self.sigma = sigma = 0.4
        self.max_iterations = max_iterations = 50
        self.alist_file = alist_file = "/home/manu/repos/ldpc/gr-ldpc/python/alist-files/96.3.963"
        self.samp_rate = samp_rate = 32000
        self.encoder = _encoder = ldpc_encoder_bf(alist_file)
        self.decoder = _decoder = ldpc_decoder_fb(alist_file, sigma, max_iterations)

        ##################################################
        # Blocks
        ##################################################
        self.generic_encoder_0 = fec.encoder(_encoder, gr.sizeof_char, gr.sizeof_float)
        self.generic_decoder_0 = fec.decoder(_decoder, gr.sizeof_float, gr.sizeof_char)
        self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, "/home/manu/Downloads/in.flac", False)
        self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, "/home/manu/Downloads/out.flac")
        self.blocks_file_sink_0.set_unbuffered(False)
        self.blocks_add_xx_0 = blocks.add_vff(1)
        self.analog_noise_source_x_0 = analog.noise_source_f(analog.GR_GAUSSIAN, 0, 0)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.analog_noise_source_x_0, 0), (self.blocks_add_xx_0, 1))
        self.connect((self.blocks_file_source_0, 0), (self.generic_encoder_0, 0))
        self.connect((self.generic_encoder_0, 0), (self.blocks_add_xx_0, 0))
        self.connect((self.blocks_add_xx_0, 0), (self.generic_decoder_0, 0))
        self.connect((self.generic_decoder_0, 0), (self.blocks_file_sink_0, 0))
    def __init__(self, encoder_obj_list, threading, puncpat=None):
        gr.hier_block2.__init__(
            self, "extended_encoder_interface",
            gr.io_signature(1, 1, gr.sizeof_char),
            gr.io_signature(1, 1, gr.sizeof_float)
            )
        self.blocks=[];
        self.puncpat=puncpat;
        
       

       

       
        if threading == 'capillary':
            self.blocks.append(capillary_threaded_encoder(encoder_obj_list))
        elif threading == 'ordinary':
            self.blocks.append(threaded_encoder(encoder_obj_list))
        else:
            self.blocks.append(fec.encoder(encoder_obj_list[0]))

       
        if self.puncpat != '11':
            self.blocks.append(fec.puncture_ff(0, read_bitlist(puncpat), puncpat.count('0'), len(puncpat)));
 
        
        

                     

        self.connect((self, 0), (self.blocks[0], 0));
        self.connect((self.blocks[-1], 0), (self, 0));

        for i in range(len(self.blocks) - 1):
            self.connect((self.blocks[i], 0), (self.blocks[i+1], 0));
Esempio n. 3
0
    def __init__(self):
        grc_wxgui.top_block_gui.__init__(self, title="Top Block")
        _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
        self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))

        ##################################################
        # Variables
        ##################################################
        self.sigma = sigma = 0.4
        self.max_iterations = max_iterations = 50
        self.alist_file = alist_file = "/home/manu/repos/ldpc/gr-ldpc/python/alist-files/96.3.963"
        self.samp_rate = samp_rate = 32000
        self.encoder = encoder = ldpc_encoder_bf(alist_file)
        self.decoder = decoder = ldpc_decoder_fb(alist_file, sigma, max_iterations)

        ##################################################
        # Blocks
        ##################################################
        self.generic_encoder_0 = fec.encoder(encoder, gr.sizeof_char, gr.sizeof_float)
        self.generic_decoder_0 = fec.decoder(decoder, gr.sizeof_float, gr.sizeof_char)
        self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, "/home/manu/Downloads/in.flac", False)
        self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, "/home/manu/Downloads/out.flac")
        self.blocks_file_sink_0.set_unbuffered(False)
        self.blocks_add_xx_0 = blocks.add_vff(1)
        self.analog_noise_source_x_0 = analog.noise_source_f(analog.GR_GAUSSIAN, 0, 0)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.analog_noise_source_x_0, 0), (self.blocks_add_xx_0, 1))
        self.connect((self.blocks_file_source_0, 0), (self.generic_encoder_0, 0))
        self.connect((self.generic_encoder_0, 0), (self.blocks_add_xx_0, 0))
        self.connect((self.blocks_add_xx_0, 0), (self.generic_decoder_0, 0))
        self.connect((self.generic_decoder_0, 0), (self.blocks_file_sink_0, 0))
Esempio n. 4
0
    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),
        )

        ##################################################
        # Parameters
        ##################################################
        self.encoder_list_0 = encoder_list_0

        ##################################################
        # Variables
        ##################################################

        ##################################################
        # Blocks
        ##################################################
        self.fec_deinterleave_0 = fec.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 = fec.interleave(
            output_size, fec.get_encoder_output_size(encoder_list_0[0]))

        ##################################################
        # Connections
        ##################################################

        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))
Esempio n. 5
0
	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),
		)

		##################################################
		# Parameters
		##################################################
		self.encoder_list_0 = encoder_list_0

		##################################################
		# Variables
		##################################################
		

		##################################################
		# Blocks
		##################################################
		self.fec_deinterleave_0 = fec.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 = fec.interleave(output_size, fec.get_encoder_output_size(encoder_list_0[0]))

		##################################################
		# Connections
		##################################################
		

		
		
		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, threading, puncpat=None):
        gr.hier_block2.__init__(self, "extended_encoder_interface",
                                gr.io_signature(1, 1, gr.sizeof_char),
                                gr.io_signature(1, 1, gr.sizeof_float))
        self.blocks = []
        self.puncpat = puncpat

        if threading == 'capillary':
            self.blocks.append(capillary_threaded_encoder(encoder_obj_list))
        elif threading == 'ordinary':
            self.blocks.append(threaded_encoder(encoder_obj_list))
        else:
            self.blocks.append(fec.encoder(encoder_obj_list[0]))

        if self.puncpat != '11':
            self.blocks.append(
                fec.puncture_ff(0, read_bitlist(puncpat), puncpat.count('0'),
                                len(puncpat)))

        self.connect((self, 0), (self.blocks[0], 0))
        self.connect((self.blocks[-1], 0), (self, 0))

        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_float):
        gr.hier_block2.__init__(
            self,
            "Capillary Threaded Encoder",
            gr.io_signature(1, 1, input_size),
            gr.io_signature(1, 1, output_size),
        )

        ##################################################
        # Parameters
        ##################################################
        self.encoder_list_0 = encoder_list_0

        ##################################################
        # Variables
        ##################################################

        ##################################################
        # Blocks
        ##################################################
        self.fec_deinterleaves_0 = []
        for i in range(int(math.log(len(encoder_list_0), 2))):
            for j in range(int(math.pow(2, i))):
                self.fec_deinterleaves_0.append(
                    fec.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_interleaves_0 = []
        for i in range(int(math.log(len(encoder_list_0), 2))):
            for j in range(int(math.pow(2, i))):
                self.fec_interleaves_0.append(
                    fec.interleave(
                        output_size,
                        fec.get_encoder_output_size(encoder_list_0[0])))

        ##################################################
        # Connections
        ##################################################

        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.fec_deinterleaves_0[rootcount], 0),
                             (self.fec_deinterleaves_0[branchcount], 0))
                self.connect((self.fec_deinterleaves_0[rootcount], 1),
                             (self.fec_deinterleaves_0[branchcount + 1], 0))
                rootcount += 1
                branchcount += 2

        codercount = 0
        for i in range(len(encoder_list_0) / 2):
            self.connect((self.fec_deinterleaves_0[rootcount], 0),
                         (self.generic_encoders_0[codercount], 0))
            self.connect((self.fec_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.fec_interleaves_0[branchcount], 0),
                             (self.fec_interleaves_0[rootcount], 0))
                self.connect((self.fec_interleaves_0[branchcount + 1], 0),
                             (self.fec_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.fec_interleaves_0[rootcount], 0))
            self.connect((self.generic_encoders_0[codercount + 1], 0),
                         (self.fec_interleaves_0[rootcount], 1))
            rootcount += 1
            codercount += 2

        if ((len(self.encoder_list_0)) > 1):
            self.connect((self, 0), (self.fec_deinterleaves_0[0], 0))
            self.connect((self.fec_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_float):
		gr.hier_block2.__init__(
			self, "Capillary Threaded Encoder",
			gr.io_signature(1, 1, input_size),
			gr.io_signature(1, 1, output_size),
		)

		##################################################
		# Parameters
		##################################################
		self.encoder_list_0 = encoder_list_0

		##################################################
		# Variables
		##################################################
		

		##################################################
		# Blocks
		##################################################
		self.fec_deinterleaves_0 = [];
		for i in range(int(math.log(len(encoder_list_0), 2))):
			for j in range(int(math.pow(2, i))):
				self.fec_deinterleaves_0.append(fec.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_interleaves_0 = [];
		for i in range(int(math.log(len(encoder_list_0), 2))):
			for j in range(int(math.pow(2, i))):
				self.fec_interleaves_0.append(fec.interleave(output_size, fec.get_encoder_output_size(encoder_list_0[0])))

		##################################################
		# Connections
		##################################################
		
		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.fec_deinterleaves_0[rootcount], 0), (self.fec_deinterleaves_0[branchcount], 0))
				self.connect((self.fec_deinterleaves_0[rootcount], 1), (self.fec_deinterleaves_0[branchcount + 1], 0))
				rootcount += 1;
				branchcount += 2;
					 
		codercount = 0;
		for i in range(len(encoder_list_0)/2):		
			self.connect((self.fec_deinterleaves_0[rootcount], 0), (self.generic_encoders_0[codercount], 0))
			self.connect((self.fec_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.fec_interleaves_0[branchcount], 0), (self.fec_interleaves_0[rootcount], 0))
				self.connect((self.fec_interleaves_0[branchcount + 1], 0), (self.fec_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.fec_interleaves_0[rootcount], 0))
			self.connect((self.generic_encoders_0[codercount + 1], 0), (self.fec_interleaves_0[rootcount], 1))
			rootcount += 1;
			codercount += 2;

		if ((len(self.encoder_list_0)) > 1):
			self.connect((self, 0), (self.fec_deinterleaves_0[0], 0))
			self.connect((self.fec_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))