Esempio n. 1
0
 def xtest_ccsds_27(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected = (0, 0, 0, 0, 1, 2, 3, 4, 5, 6)
     src = gr.vector_source_b(src_data)
     enc = gr.encode_ccsds_27_bb()
     b2f = gr.char_to_float()
     add = gr.add_const_ff(-0.5)
     mul = gr.multiply_const_ff(2.0)
     dec = gr.decode_ccsds_27_fb()
     dst = gr.vector_sink_b()
     self.tb.connect(src, enc, b2f, add, mul, dec, dst)
     self.tb.run()
     dst_data = dst.data()
     self.assertEqual(expected, dst_data)
Esempio n. 2
0
    def xtest_ccsds_27 (self):
        src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	expected = (0, 0, 0, 0, 1, 2, 3, 4, 5, 6)
        src = gr.vector_source_b(src_data)
	enc = gr.encode_ccsds_27_bb()
	b2f = gr.char_to_float()
	add = gr.add_const_ff(-0.5)
	mul = gr.multiply_const_ff(2.0)
	dec = gr.decode_ccsds_27_fb()
	dst = gr.vector_sink_b()
	self.tb.connect(src, enc, b2f, add, mul, dec, dst)
	self.tb.run()
	dst_data = dst.data()
        self.assertEqual(expected, dst_data)
Esempio n. 3
0
    def __init__(
            self,
            sample_rate,
            ber_threshold=0,  # Above which to do search
            ber_smoothing=0,  # Alpha of BER smoother (0.01)
            ber_duration=0,  # Length before trying next combo
            ber_sample_decimation=1,
            settling_period=0,
            pre_lock_duration=0,
            #ber_sample_skip=0
            **kwargs):

        use_throttle = False
        base_duration = 1024
        if sample_rate > 0:
            use_throttle = True
            base_duration *= 4  # Has to be high enough for block-delay

        if ber_threshold == 0:
            ber_threshold = 512 * 4
        if ber_smoothing == 0:
            ber_smoothing = 0.01
        if ber_duration == 0:
            ber_duration = base_duration * 2  # 1000ms
        if settling_period == 0:
            settling_period = base_duration * 1  # 500ms
        if pre_lock_duration == 0:
            pre_lock_duration = base_duration * 2  #1000ms

        print "Creating Auto-FEC:"
        print "\tsample_rate:\t\t", sample_rate
        print "\tber_threshold:\t\t", ber_threshold
        print "\tber_smoothing:\t\t", ber_smoothing
        print "\tber_duration:\t\t", ber_duration
        print "\tber_sample_decimation:\t", ber_sample_decimation
        print "\tsettling_period:\t", settling_period
        print "\tpre_lock_duration:\t", pre_lock_duration
        print ""

        self.sample_rate = sample_rate
        self.ber_threshold = ber_threshold
        #self.ber_smoothing = ber_smoothing
        self.ber_duration = ber_duration
        self.settling_period = settling_period
        self.pre_lock_duration = pre_lock_duration
        #self.ber_sample_skip = ber_sample_skip

        self.data_lock = threading.Lock()

        gr.hier_block2.__init__(
            self,
            "auto_fec",
            gr.io_signature(
                1, 1,
                gr.sizeof_gr_complex),  # Post MPSK-receiver complex input
            gr.io_signature3(
                3, 3, gr.sizeof_char, gr.sizeof_float,
                gr.sizeof_float))  # Decoded packed bytes, BER metric, lock

        self.input_watcher = auto_fec_input_watcher(self)
        default_xform = self.input_watcher.xform_lock

        self.gr_conjugate_cc_0 = gr.conjugate_cc()
        self.connect((self, 0), (self.gr_conjugate_cc_0, 0))  # Input

        self.blks2_selector_0 = grc_blks2.selector(
            item_size=gr.sizeof_gr_complex * 1,
            num_inputs=2,
            num_outputs=1,
            input_index=default_xform.get_conjugation_index(),
            output_index=0,
        )
        self.connect((self.gr_conjugate_cc_0, 0), (self.blks2_selector_0, 0))
        self.connect((self, 0), (self.blks2_selector_0, 1))  # Input

        self.gr_multiply_const_vxx_3 = gr.multiply_const_vcc(
            (0.707 * (1 + 1j), ))
        self.connect((self.blks2_selector_0, 0),
                     (self.gr_multiply_const_vxx_3, 0))

        self.gr_multiply_const_vxx_2 = gr.multiply_const_vcc(
            (default_xform.get_rotation(), ))  # phase_mult
        self.connect((self.gr_multiply_const_vxx_3, 0),
                     (self.gr_multiply_const_vxx_2, 0))

        self.gr_complex_to_float_0_0 = gr.complex_to_float(1)
        self.connect((self.gr_multiply_const_vxx_2, 0),
                     (self.gr_complex_to_float_0_0, 0))

        self.gr_interleave_1 = gr.interleave(gr.sizeof_float * 1)
        self.connect((self.gr_complex_to_float_0_0, 1),
                     (self.gr_interleave_1, 1))
        self.connect((self.gr_complex_to_float_0_0, 0),
                     (self.gr_interleave_1, 0))

        self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((1, ))  # invert
        self.connect((self.gr_interleave_1, 0),
                     (self.gr_multiply_const_vxx_0, 0))

        self.baz_delay_2 = baz.delay(
            gr.sizeof_float * 1,
            default_xform.get_puncture_delay())  # delay_puncture
        self.connect((self.gr_multiply_const_vxx_0, 0), (self.baz_delay_2, 0))

        self.depuncture_ff_0 = baz.depuncture_ff(
            (_puncture_matrices[self.input_watcher.puncture_matrix][1]
             ))  # puncture_matrix
        self.connect((self.baz_delay_2, 0), (self.depuncture_ff_0, 0))

        self.baz_delay_1 = baz.delay(
            gr.sizeof_float * 1,
            default_xform.get_viterbi_delay())  # delay_viterbi
        self.connect((self.depuncture_ff_0, 0), (self.baz_delay_1, 0))

        self.swap_ff_0 = baz.swap_ff(
            default_xform.get_viterbi_swap())  # swap_viterbi
        self.connect((self.baz_delay_1, 0), (self.swap_ff_0, 0))

        self.gr_decode_ccsds_27_fb_0 = gr.decode_ccsds_27_fb()

        if use_throttle:
            print "==> Using throttle at sample rate:", self.sample_rate
            self.gr_throttle_0 = gr.throttle(gr.sizeof_float, self.sample_rate)
            self.connect((self.swap_ff_0, 0), (self.gr_throttle_0, 0))
            self.connect((self.gr_throttle_0, 0),
                         (self.gr_decode_ccsds_27_fb_0, 0))
        else:
            self.connect((self.swap_ff_0, 0),
                         (self.gr_decode_ccsds_27_fb_0, 0))

        self.connect((self.gr_decode_ccsds_27_fb_0, 0),
                     (self, 0))  # Output bytes

        self.gr_add_const_vxx_1 = gr.add_const_vff((-4096, ))
        self.connect((self.gr_decode_ccsds_27_fb_0, 1),
                     (self.gr_add_const_vxx_1, 0))

        self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((-1, ))
        self.connect((self.gr_add_const_vxx_1, 0),
                     (self.gr_multiply_const_vxx_1, 0))
        self.connect((self.gr_multiply_const_vxx_1, 0),
                     (self, 1))  # Output BER

        self.gr_single_pole_iir_filter_xx_0 = gr.single_pole_iir_filter_ff(
            ber_smoothing, 1)
        self.connect((self.gr_multiply_const_vxx_1, 0),
                     (self.gr_single_pole_iir_filter_xx_0, 0))

        self.gr_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_float,
                                                       ber_sample_decimation)
        self.connect((self.gr_single_pole_iir_filter_xx_0, 0),
                     (self.gr_keep_one_in_n_0, 0))

        self.const_source_x_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0,
                                                0)  # Last param is const value
        if use_throttle:
            lock_throttle_rate = self.sample_rate // 16
            print "==> Using lock throttle rate:", lock_throttle_rate
            self.gr_throttle_1 = gr.throttle(gr.sizeof_float,
                                             lock_throttle_rate)
            self.connect((self.const_source_x_0, 0), (self.gr_throttle_1, 0))
            self.connect((self.gr_throttle_1, 0), (self, 2))
        else:
            self.connect((self.const_source_x_0, 0), (self, 2))

        self.msg_q = gr.msg_queue(
            2 * 256
        )  # message queue that holds at most 2 messages, increase to speed up process
        self.msg_sink = gr.message_sink(
            gr.sizeof_float, self.msg_q,
            dont_block=0)  # Block to speed up process
        self.connect((self.gr_keep_one_in_n_0, 0), self.msg_sink)

        self.input_watcher.start()
Esempio n. 4
0
	def __init__(self,
		sample_rate,
		ber_threshold=0,	# Above which to do search
		ber_smoothing=0,	# Alpha of BER smoother (0.01)
		ber_duration=0,		# Length before trying next combo
		ber_sample_decimation=1,
		settling_period=0,
		pre_lock_duration=0,
		#ber_sample_skip=0
		**kwargs):
		
		use_throttle = False
		base_duration = 1024
		if sample_rate > 0:
			use_throttle = True
			base_duration *= 4	# Has to be high enough for block-delay
		
		if ber_threshold == 0:
			ber_threshold = 512 * 4
		if ber_smoothing == 0:
			ber_smoothing = 0.01
		if ber_duration == 0:
			ber_duration = base_duration * 2 # 1000ms
		if settling_period == 0:
			settling_period = base_duration * 1 # 500ms
		if pre_lock_duration == 0:
			pre_lock_duration = base_duration * 2 #1000ms
		
		print "Creating Auto-FEC:"
		print "\tsample_rate:\t\t", sample_rate
		print "\tber_threshold:\t\t", ber_threshold
		print "\tber_smoothing:\t\t", ber_smoothing
		print "\tber_duration:\t\t", ber_duration
		print "\tber_sample_decimation:\t", ber_sample_decimation
		print "\tsettling_period:\t", settling_period
		print "\tpre_lock_duration:\t", pre_lock_duration
		print ""
		
		self.sample_rate = sample_rate
		self.ber_threshold = ber_threshold
		#self.ber_smoothing = ber_smoothing
		self.ber_duration = ber_duration
		self.settling_period = settling_period
		self.pre_lock_duration = pre_lock_duration
		#self.ber_sample_skip = ber_sample_skip
		
		self.data_lock = threading.Lock()

		gr.hier_block2.__init__(self, "auto_fec",
			gr.io_signature(1, 1, gr.sizeof_gr_complex),			# Post MPSK-receiver complex input
			gr.io_signature3(3, 3, gr.sizeof_char, gr.sizeof_float, gr.sizeof_float))	# Decoded packed bytes, BER metric, lock
		
		self.input_watcher = auto_fec_input_watcher(self)
		default_xform = self.input_watcher.xform_lock
		
		self.gr_conjugate_cc_0 = gr.conjugate_cc()
		self.connect((self, 0), (self.gr_conjugate_cc_0, 0))	# Input
		
		self.blks2_selector_0 = grc_blks2.selector(
			item_size=gr.sizeof_gr_complex*1,
			num_inputs=2,
			num_outputs=1,
			input_index=default_xform.get_conjugation_index(),
			output_index=0,
		)
		self.connect((self.gr_conjugate_cc_0, 0), (self.blks2_selector_0, 0))
		self.connect((self, 0), (self.blks2_selector_0, 1))		# Input
		
		self.gr_multiply_const_vxx_3 = gr.multiply_const_vcc((0.707*(1+1j), ))
		self.connect((self.blks2_selector_0, 0), (self.gr_multiply_const_vxx_3, 0))
		
		self.gr_multiply_const_vxx_2 = gr.multiply_const_vcc((default_xform.get_rotation(), ))	# phase_mult
		self.connect((self.gr_multiply_const_vxx_3, 0), (self.gr_multiply_const_vxx_2, 0))
		
		self.gr_complex_to_float_0_0 = gr.complex_to_float(1)
		self.connect((self.gr_multiply_const_vxx_2, 0), (self.gr_complex_to_float_0_0, 0))
		
		self.gr_interleave_1 = gr.interleave(gr.sizeof_float*1)
		self.connect((self.gr_complex_to_float_0_0, 1), (self.gr_interleave_1, 1))
		self.connect((self.gr_complex_to_float_0_0, 0), (self.gr_interleave_1, 0))
		
		self.gr_multiply_const_vxx_0 = gr.multiply_const_vff((1, ))	# invert
		self.connect((self.gr_interleave_1, 0), (self.gr_multiply_const_vxx_0, 0))
		
		self.baz_delay_2 = baz.delay(gr.sizeof_float*1, default_xform.get_puncture_delay())	# delay_puncture
		self.connect((self.gr_multiply_const_vxx_0, 0), (self.baz_delay_2, 0))
		
		self.depuncture_ff_0 = baz.depuncture_ff((_puncture_matrices[self.input_watcher.puncture_matrix][1]))	# puncture_matrix
		self.connect((self.baz_delay_2, 0), (self.depuncture_ff_0, 0))
		
		self.baz_delay_1 = baz.delay(gr.sizeof_float*1, default_xform.get_viterbi_delay())	# delay_viterbi
		self.connect((self.depuncture_ff_0, 0), (self.baz_delay_1, 0))
		
		self.swap_ff_0 = baz.swap_ff(default_xform.get_viterbi_swap())	# swap_viterbi
		self.connect((self.baz_delay_1, 0), (self.swap_ff_0, 0))
		
		self.gr_decode_ccsds_27_fb_0 = gr.decode_ccsds_27_fb()
		
		if use_throttle:
			print "==> Using throttle at sample rate:", self.sample_rate
			self.gr_throttle_0 = gr.throttle(gr.sizeof_float, self.sample_rate)
			self.connect((self.swap_ff_0, 0), (self.gr_throttle_0, 0))
			self.connect((self.gr_throttle_0, 0), (self.gr_decode_ccsds_27_fb_0, 0))
		else:
			self.connect((self.swap_ff_0, 0), (self.gr_decode_ccsds_27_fb_0, 0))
		
		self.connect((self.gr_decode_ccsds_27_fb_0, 0), (self, 0))	# Output bytes
		
		self.gr_add_const_vxx_1 = gr.add_const_vff((-4096, ))
		self.connect((self.gr_decode_ccsds_27_fb_0, 1), (self.gr_add_const_vxx_1, 0))
		
		self.gr_multiply_const_vxx_1 = gr.multiply_const_vff((-1, ))
		self.connect((self.gr_add_const_vxx_1, 0), (self.gr_multiply_const_vxx_1, 0))
		self.connect((self.gr_multiply_const_vxx_1, 0), (self, 1))	# Output BER
		
		self.gr_single_pole_iir_filter_xx_0 = gr.single_pole_iir_filter_ff(ber_smoothing, 1)
		self.connect((self.gr_multiply_const_vxx_1, 0), (self.gr_single_pole_iir_filter_xx_0, 0))
		
		self.gr_keep_one_in_n_0 = blocks.keep_one_in_n(gr.sizeof_float, ber_sample_decimation)
		self.connect((self.gr_single_pole_iir_filter_xx_0, 0), (self.gr_keep_one_in_n_0, 0))
		
		self.const_source_x_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 0)	# Last param is const value
		if use_throttle:
			lock_throttle_rate = self.sample_rate // 16
			print "==> Using lock throttle rate:", lock_throttle_rate
			self.gr_throttle_1 = gr.throttle(gr.sizeof_float, lock_throttle_rate)
			self.connect((self.const_source_x_0, 0), (self.gr_throttle_1, 0))
			self.connect((self.gr_throttle_1, 0), (self, 2))
		else:
			self.connect((self.const_source_x_0, 0), (self, 2))
		
		self.msg_q = gr.msg_queue(2*256)	# message queue that holds at most 2 messages, increase to speed up process
		self.msg_sink = gr.message_sink(gr.sizeof_float, self.msg_q, dont_block=0)	# Block to speed up process
		self.connect((self.gr_keep_one_in_n_0, 0), self.msg_sink)
		
		self.input_watcher.start()