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)
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())
