def test_explain(self): f = MultistageChannelFilter(input_rate=10000, output_rate=1000, cutoff_freq=500, transition_width=100) self.assertEqual(f.explain(), textwrap.dedent('''\ 2 stages from 10000 to 1000 decimate by 5 using 43 taps (86000) in freq_xlating_fir_filter_ccc_sptr decimate by 2 using 49 taps (49000) in fft_filter_ccc_sptr No final resampler stage.'''))
def __init__(self, demod_rate=0, audio_rate=0, band_filter=None, band_filter_transition=None, stereo=False, **kwargs): assert audio_rate > 0 self.__signal_type = SignalType(kind='STEREO' if stereo else 'MONO', sample_rate=audio_rate) Demodulator.__init__(self, **kwargs) SquelchMixin.__init__(self, demod_rate) self.band_filter = band_filter self.band_filter_transition = band_filter_transition self.demod_rate = demod_rate self.audio_rate = audio_rate input_rate = self.input_rate self.band_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=band_filter, transition_width=band_filter_transition)
class SimpleAudioDemodulator(Demodulator, SquelchMixin): implements(ITunableDemodulator) def __init__(self, demod_rate=0, band_filter=None, band_filter_transition=None, **kwargs): Demodulator.__init__(self, **kwargs) SquelchMixin.__init__(self, demod_rate) self.band_filter = band_filter self.band_filter_transition = band_filter_transition self.demod_rate = demod_rate input_rate = self.input_rate audio_rate = self.audio_rate self.band_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=band_filter, transition_width=band_filter_transition) def get_half_bandwidth(self): return self.band_filter def set_rec_freq(self, freq): '''for ITunableDemodulator''' self.band_filter_block.set_center_freq(freq) @exported_value() def get_band_filter_shape(self): return { 'low': -self.band_filter, 'high': self.band_filter, 'width': self.band_filter_transition }
def test_setters(self): # TODO: Test filter functionality; this only tests that the operations work filt = MultistageChannelFilter(input_rate=32000000, output_rate=16000, cutoff_freq=3000, transition_width=1200) filt.set_cutoff_freq(2900) filt.set_transition_width(1000) filt.set_center_freq(10000) self.assertEqual(2900, filt.get_cutoff_freq()) self.assertEqual(1000, filt.get_transition_width()) self.assertEqual(10000, filt.get_center_freq())
def test_explain(self): f = MultistageChannelFilter(input_rate=10000, output_rate=1000, cutoff_freq=500, transition_width=100) self.assertEqual( f.explain(), textwrap.dedent('''\ 2 stages from 10000 to 1000 decimate by 5 using 43 taps (86000) in freq_xlating_fir_filter_ccc_sptr decimate by 2 using 49 taps (49000) in fft_filter_ccc_sptr No final resampler stage.'''))
class SimpleAudioDemodulator(Demodulator, SquelchMixin): implements(ITunableDemodulator) def __init__(self, demod_rate=0, audio_rate=0, band_filter=None, band_filter_transition=None, stereo=False, **kwargs): assert audio_rate > 0 self.__signal_type = SignalType(kind='STEREO' if stereo else 'MONO', sample_rate=audio_rate) Demodulator.__init__(self, **kwargs) SquelchMixin.__init__(self, demod_rate) self.band_filter = band_filter self.band_filter_transition = band_filter_transition self.demod_rate = demod_rate self.audio_rate = audio_rate input_rate = self.input_rate self.band_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=band_filter, transition_width=band_filter_transition) def get_half_bandwidth(self): return self.band_filter def get_output_type(self): return self.__signal_type def set_rec_freq(self, freq): '''for ITunableDemodulator''' self.band_filter_block.set_center_freq(freq) @exported_value() def get_band_filter_shape(self): return { 'low': -self.band_filter, 'high': self.band_filter, 'width': self.band_filter_transition }
def test_basic(self): # TODO: Test filter functionality more f = MultistageChannelFilter(input_rate=32000000, output_rate=16000, cutoff_freq=3000, transition_width=1200) self.__run(f, 400000, 16000 / 32000000)
def test_float_rates(self): # Either float or int rates should be accepted f = MultistageChannelFilter(input_rate=32000000.0, output_rate=16000.0, cutoff_freq=3000, transition_width=1200) self.__run(f, 400000, 16000 / 32000000)
def test_decimating(self): '''Sample problematic decimation case''' # TODO: Test filter functionality more f = MultistageChannelFilter(input_rate=8000000, output_rate=48000, cutoff_freq=10000, transition_width=5000) self.__run(f, 400000, 48000 / 8000000)
def test_odd_interpolating(self): '''Output rate higher than input rate and not a multiple''' # TODO: Test filter functionality more f = MultistageChannelFilter(input_rate=8000, output_rate=21234, cutoff_freq=8000, transition_width=5000) self.__run(f, 4000, 21234 / 8000)
class SimpleAudioDemodulator(Demodulator, SquelchMixin): implements(ITunableDemodulator) def __init__(self, demod_rate=0, audio_rate=0, band_filter=None, band_filter_transition=None, stereo=False, **kwargs): assert audio_rate > 0 self.__signal_type = SignalType( kind='STEREO' if stereo else 'MONO', sample_rate=audio_rate) Demodulator.__init__(self, **kwargs) SquelchMixin.__init__(self, demod_rate) self.band_filter = band_filter self.band_filter_transition = band_filter_transition self.demod_rate = demod_rate self.audio_rate = audio_rate input_rate = self.input_rate self.band_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=band_filter, transition_width=band_filter_transition) def get_half_bandwidth(self): return self.band_filter def get_output_type(self): return self.__signal_type def set_rec_freq(self, freq): '''for ITunableDemodulator''' self.band_filter_block.set_center_freq(freq) @exported_value() def get_band_filter_shape(self): return { 'low': -self.band_filter, 'high': self.band_filter, 'width': self.band_filter_transition }
def test_one_filter(**kwargs): print '------ %s -------' % (kwargs, ) f = MultistageChannelFilter(**kwargs) size = 10000000 top = gr.top_block() top.connect(blocks.vector_source_c([5] * size), f, blocks.null_sink(gr.sizeof_gr_complex)) print f.explain() t0 = time.clock() top.start() top.wait() top.stop() t1 = time.clock() print size, 'samples processed in', t1 - t0, 'CPU-seconds'
def __init__(self, mode='MODE-S', input_rate=0, mode_s_information=None, context=None): assert input_rate > 0 gr.hier_block2.__init__( self, 'Mode S/ADS-B/1090 demodulator', gr.io_signature(1, 1, gr.sizeof_gr_complex * 1), gr.io_signature(0, 0, 0)) self.mode = mode self.input_rate = input_rate if mode_s_information is not None: self.__information = mode_s_information else: self.__information = ModeSInformation() hex_msg_queue = gr.msg_queue(100) band_filter = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=demod_rate / 2, transition_width=transition_width) # TODO optimize filter band self.__demod = air_modes.rx_path( rate=demod_rate, threshold=7.0, # default used in air-modes code but not exposed queue=hex_msg_queue, use_pmf=False, use_dcblock=True) self.connect(self, band_filter, self.__demod) # Parsing # TODO: These bits are mimicking gr-air-modes toplevel code. Figure out if we can have less glue. # Note: gr pubsub is synchronous -- subscribers are called on the publisher's thread parser_output = gr.pubsub.pubsub() parser = air_modes.make_parser(parser_output) cpr_decoder = air_modes.cpr_decoder( my_location=None) # TODO: get position info from device air_modes.output_print(cpr_decoder, parser_output) def callback(msg): # called on msgq_runner's thrad # pylint: disable=broad-except try: reactor.callFromThread(parser, msg.to_string()) except Exception: print traceback.format_exc() self.__msgq_runner = gru.msgq_runner(hex_msg_queue, callback) def parsed_callback(msg): self.__information.receive(msg, cpr_decoder) for i in xrange(0, 2**5): parser_output.subscribe('type%i_dl' % i, parsed_callback)
def test_one_filter(**kwargs): print '------ %s -------' % (kwargs,) f = MultistageChannelFilter(**kwargs) size = 10000000 top = gr.top_block() top.connect( blocks.vector_source_c([5] * size), f, blocks.null_sink(gr.sizeof_gr_complex)) print f.explain() t0 = time.clock() top.start() top.wait() top.stop() t1 = time.clock() print size, 'samples processed in', t1 - t0, 'CPU-seconds'
def __init__(self, demod_rate=0, band_filter=None, band_filter_transition=None, **kwargs): Demodulator.__init__(self, **kwargs) SquelchMixin.__init__(self, demod_rate) self.band_filter = band_filter self.band_filter_transition = band_filter_transition self.demod_rate = demod_rate input_rate = self.input_rate audio_rate = self.audio_rate self.band_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=band_filter, transition_width=band_filter_transition)
def __init__(self, mode, input_rate=0, context=None): assert input_rate > 0 gr.hier_block2.__init__( self, 'RTTY demodulator', gr.io_signature(1, 1, gr.sizeof_gr_complex * 1), gr.io_signature(1, 1, gr.sizeof_float * 1), ) self.__text = u'' baud = _DEFAULT_BAUD # TODO param self.baud = baud demod_rate = 6000 # TODO optimize this value self.samp_rate = demod_rate # TODO rename self.__channel_filter = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=self.__filter_high, transition_width=self.__transition) # TODO optimize filter band self.__sharp_filter = grfilter.fir_filter_ccc( 1, firdes.complex_band_pass(1.0, demod_rate, self.__filter_low, self.__filter_high, self.__transition, firdes.WIN_HAMMING)) self.fsk_demod = RTTYFSKDemodulator(input_rate=demod_rate, baud=baud) self.__real = blocks.complex_to_real(vlen=1) self.__char_queue = gr.msg_queue(limit=100) self.char_sink = blocks.message_sink(gr.sizeof_char, self.__char_queue, True) self.connect( self, self.__channel_filter, self.__sharp_filter, self.fsk_demod, rtty.rtty_decode_ff(rate=demod_rate, baud=baud, polarity=False), self.char_sink) self.connect( self.__sharp_filter, self.__real, self)
def __init__(self, demod_rate=0, audio_rate=0, band_filter=None, band_filter_transition=None, stereo=False, **kwargs): assert audio_rate > 0 self.__signal_type = SignalType( kind='STEREO' if stereo else 'MONO', sample_rate=audio_rate) Demodulator.__init__(self, **kwargs) SquelchMixin.__init__(self, demod_rate) self.band_filter = band_filter self.band_filter_transition = band_filter_transition self.demod_rate = demod_rate self.audio_rate = audio_rate input_rate = self.input_rate self.band_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=band_filter, transition_width=band_filter_transition)