class ChannelFilterMixin(object): """Provides a MultistageChannelFilter block and matching implementations of get_band_shape and ITunableDemodulator. Does not make any connection automatically. """ def __init__(self, input_rate=0, demod_rate=0, cutoff_freq=0, transition_width=0): # mandatory keyword arguments assert input_rate > 0 assert demod_rate > 0 assert cutoff_freq > 0 assert transition_width > 0 self.channel_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=cutoff_freq, transition_width=transition_width) @exported_value(type=BandShape, changes='never') def get_band_shape(self): """Implements IDemodulator.""" return self.channel_filter_block.get_shape() def set_rec_freq(self, freq): """Implements ITunableDemodulator.""" self.channel_filter_block.set_center_freq(freq)
class SimpleAudioDemodulator(Demodulator, SquelchMixin): 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.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) @exported_value(type=BandShape, changes='never') # TODO not sure if this is the right change policy def get_band_shape(self): """Implements IDemodulator.""" return self.band_filter_block.get_shape() def get_output_type(self): """Implements IDemodulator.""" return self.__signal_type def set_rec_freq(self, freq): """Implements ITunableDemodulator.""" self.band_filter_block.set_center_freq(freq)
class ChannelFilterMixin(object): """Provides a MultistageChannelFilter block and matching implementations of get_band_shape and ITunableDemodulator. Does not make any connection automatically. """ def __init__(self, input_rate=0, demod_rate=0, cutoff_freq=0, transition_width=0): # mandatory keyword arguments assert input_rate > 0 assert demod_rate > 0 assert cutoff_freq > 0 assert transition_width > 0 self.channel_filter_block = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=cutoff_freq, transition_width=transition_width) @exported_value(type=BandShape, changes='never') def get_band_shape(self): """Implements IDemodulator.""" return self.channel_filter_block.get_shape() def set_rec_freq(self, freq): """Implements ITunableDemodulator.""" self.channel_filter_block.set_center_freq(freq)
class SimpleAudioDemodulator(Demodulator, SquelchMixin): 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.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) @exported_value(type=BandShape, changes='never') # TODO not sure if this is the right change policy def get_band_shape(self): """Implements IDemodulator.""" return self.band_filter_block.get_shape() def get_output_type(self): """Implements IDemodulator.""" return self.__signal_type def set_rec_freq(self, freq): """Implements ITunableDemodulator.""" self.band_filter_block.set_center_freq(freq)
class RTL433Demodulator(gr.hier_block2, ExportedState): def __init__(self, mode='433', input_rate=0, context=None): assert input_rate > 0 assert context is not None gr.hier_block2.__init__( self, type(self).__name__, gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) # The input bandwidth chosen is not primarily determined by the bandwidth of the input signals, but by the frequency error of the transmitters. Therefore it is not too critical, and we can choose the exact rate to make the filtering easy. if input_rate <= upper_preferred_demod_rate: # Skip having a filter at all. self.__band_filter = None demod_rate = input_rate else: # TODO: This gunk is very similar to the stuff that MultistageChannelFilter does. See if we can share some code. lower_rate = input_rate lower_rate_prev = None while lower_rate > upper_preferred_demod_rate and lower_rate != lower_rate_prev: lower_rate_prev = lower_rate if lower_rate % 5 == 0 and lower_rate > upper_preferred_demod_rate * 3: lower_rate /= 5 elif lower_rate % 2 == 0: lower_rate /= 2 else: # non-integer ratio lower_rate = upper_preferred_demod_rate break demod_rate = lower_rate self.__band_filter = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=demod_rate * 0.4, transition_width=demod_rate * 0.2) # Subprocess # using /usr/bin/env because twisted spawnProcess doesn't support path search # pylint: disable=no-member process = the_reactor.spawnProcess( RTL433ProcessProtocol(context.output_message), '/usr/bin/env', env=None, # inherit environment args=[ 'env', 'rtl_433', '-F', 'json', '-r', '-', # read from stdin '-m', '3', # complex float input '-s', str(demod_rate), ], childFDs={ 0: 'w', 1: 'r', 2: 2 }) sink = make_sink_to_process_stdin(process, itemsize=gr.sizeof_gr_complex) agc = analog.agc2_cc(reference=dB(-4)) agc.set_attack_rate(200 / demod_rate) agc.set_decay_rate(200 / demod_rate) if self.__band_filter: self.connect( self, self.__band_filter, agc) else: self.connect( self, agc) self.connect(agc, sink) @exported_value(type=BandShape, changes='never') def get_band_shape(self): """implements IDemodulator""" if self.__band_filter: return self.__band_filter.get_shape() else: # TODO Reuse UnselectiveAMDemodulator's approach to this return BandShape(stop_low=0, pass_low=0, pass_high=0, stop_high=0, markers={}) def get_output_type(self): """implements IDemodulator""" return no_signal
class RTL433Demodulator(gr.hier_block2, ExportedState): implements(IDemodulator) def __init__(self, mode='433', input_rate=0, context=None): assert input_rate > 0 assert context is not None gr.hier_block2.__init__(self, type(self).__name__, gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) # The input bandwidth chosen is not primarily determined by the bandwidth of the input signals, but by the frequency error of the transmitters. Therefore it is not too critical, and we can choose the exact rate to make the filtering easy. if input_rate <= upper_preferred_demod_rate: # Skip having a filter at all. self.__band_filter = None demod_rate = input_rate else: # TODO: This gunk is very similar to the stuff that MultistageChannelFilter does. See if we can share some code. lower_rate = input_rate lower_rate_prev = None while lower_rate > upper_preferred_demod_rate and lower_rate != lower_rate_prev: lower_rate_prev = lower_rate if lower_rate % 5 == 0 and lower_rate > upper_preferred_demod_rate * 3: lower_rate /= 5 elif lower_rate % 2 == 0: lower_rate /= 2 else: # non-integer ratio lower_rate = upper_preferred_demod_rate break demod_rate = lower_rate self.__band_filter = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=demod_rate * 0.4, transition_width=demod_rate * 0.2) # Subprocess # using /usr/bin/env because twisted spawnProcess doesn't support path search # pylint: disable=no-member process = the_reactor.spawnProcess( RTL433ProcessProtocol(context.output_message), '/usr/bin/env', env=None, # inherit environment args=[ 'env', 'rtl_433', '-F', 'json', '-r', '-', # read from stdin '-m', '3', # complex float input '-s', str(demod_rate), ], childFDs={ 0: 'w', 1: 'r', 2: 2 }) sink = make_sink_to_process_stdin(process, itemsize=gr.sizeof_gr_complex) agc = analog.agc2_cc(reference=dB(-4)) agc.set_attack_rate(200 / demod_rate) agc.set_decay_rate(200 / demod_rate) if self.__band_filter: self.connect(self, self.__band_filter, agc) else: self.connect(self, agc) self.connect(agc, sink) def can_set_mode(self, mode): """implements IDemodulator""" return False @exported_value() def get_band_filter_shape(self): """implements IDemodulator""" if self.__band_filter: return self.__band_filter.get_shape() else: # TODO stub return {'low': 0, 'high': 0, 'width': 0} def get_output_type(self): """implements IDemodulator""" return no_signal
class ModeSDemodulator(gr.hier_block2, ExportedState): def __init__(self, mode='MODE-S', input_rate=0, context=None): assert input_rate > 0 gr.hier_block2.__init__( self, type(self).__name__, gr.io_signature(1, 1, gr.sizeof_gr_complex * 1), gr.io_signature(0, 0, 0)) demod_rate = 2000000 transition_width = 500000 hex_msg_queue = gr.msg_queue(100) self.__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, self.__band_filter, self.__demod) self.__messages_seen = 0 self.__message_rate_calc = LazyRateCalculator( lambda: self.__messages_seen, min_interval=2) # 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 msq_runner_callback(msg): # called on msgq_runner's thread # 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, msq_runner_callback) def parsed_callback(msg): timestamp = time.time() self.__messages_seen += 1 context.output_message( ModeSMessageWrapper(msg, cpr_decoder, timestamp)) for i in six.moves.range(0, 2**5): parser_output.subscribe('type%i_dl' % i, parsed_callback) def __del__(self): self.__msgq_runner.stop() @exported_value(type=RangeT([(0, 30)], unit=units.dB), changes='this_setter', label='Decode threshold') def get_decode_threshold(self): return self.__demod.get_threshold() @setter def set_decode_threshold(self, value): self.__demod.set_threshold(float(value)) @exported_value(float, changes='continuous', label='Messages/sec decoded') def get_message_rate(self): return round(self.__message_rate_calc.get(), 1) def get_output_type(self): return no_signal @exported_value(type=BandShape, changes='never') def get_band_shape(self): return self.__band_filter.get_shape()
class ModeSDemodulator(gr.hier_block2, ExportedState): def __init__(self, mode='MODE-S', input_rate=0, 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)) demod_rate = 2000000 transition_width = 500000 hex_msg_queue = gr.msg_queue(100) self.__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, self.__band_filter, self.__demod) self.__messages_seen = 0 self.__message_rate_calc = LazyRateCalculator(lambda: self.__messages_seen, min_interval=2) # 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 msq_runner_callback(msg): # called on msgq_runner's thread # 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, msq_runner_callback) def parsed_callback(msg): timestamp = time.time() self.__messages_seen += 1 context.output_message(ModeSMessageWrapper(msg, cpr_decoder, timestamp)) for i in xrange(0, 2 ** 5): parser_output.subscribe('type%i_dl' % i, parsed_callback) def __del__(self): self.__msgq_runner.stop() @exported_value(type=RangeT([(0, 30)], unit=units.dB), changes='this_setter', label='Decode threshold') def get_decode_threshold(self): return self.__demod.get_threshold() @setter def set_decode_threshold(self, value): self.__demod.set_threshold(float(value)) @exported_value(float, changes='continuous', label='Messages/sec decoded') def get_message_rate(self): return round(self.__message_rate_calc.get(), 1) def get_output_type(self): return no_signal @exported_value(type=BandShape, changes='never') def get_band_shape(self): return self.__band_filter.get_shape()
class RTL433Demodulator(gr.hier_block2, ExportedState): __log = Logger() # TODO: log to context/client def __init__(self, mode='433', input_rate=0, context=None): assert input_rate > 0 assert context is not None gr.hier_block2.__init__(self, type(self).__name__, gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0, 0, 0)) # The input bandwidth chosen is not primarily determined by the bandwidth of the input signals, but by the frequency error of the transmitters. Therefore it is not too critical, and we can choose the exact rate to make the filtering easy. if input_rate <= upper_preferred_demod_rate: # Skip having a filter at all. self.__band_filter = None demod_rate = input_rate else: # TODO: This gunk is very similar to the stuff that MultistageChannelFilter does. See if we can share some code. lower_rate = input_rate lower_rate_prev = None while lower_rate > upper_preferred_demod_rate and lower_rate != lower_rate_prev: lower_rate_prev = lower_rate if lower_rate % 5 == 0 and lower_rate > upper_preferred_demod_rate * 3: lower_rate /= 5 elif lower_rate % 2 == 0: lower_rate /= 2 else: # non-integer ratio lower_rate = upper_preferred_demod_rate break demod_rate = lower_rate self.__band_filter = MultistageChannelFilter( input_rate=input_rate, output_rate=demod_rate, cutoff_freq=demod_rate * 0.4, transition_width=demod_rate * 0.2) # Subprocess # using /usr/bin/env because twisted spawnProcess doesn't support path search # pylint: disable=no-member self.__process = the_reactor.spawnProcess( RTL433ProcessProtocol(context.output_message, self.__log), '/usr/bin/env', env=None, # inherit environment args=[ b'env', b'rtl_433', b'-F', b'json', b'-r', b'-', # read from stdin b'-m', b'3', # complex float input b'-s', str(demod_rate), b'-q' # quiet mode, suppress "Registering protocol..." stderr flood ], childFDs={ 0: 'w', 1: 'r', 2: 2 }) sink = make_sink_to_process_stdin(self.__process, itemsize=gr.sizeof_gr_complex) agc = analog.agc2_cc(reference=dB(-4)) agc.set_attack_rate(200 / demod_rate) agc.set_decay_rate(200 / demod_rate) if self.__band_filter: self.connect(self, self.__band_filter, agc) else: self.connect(self, agc) self.connect(agc, sink) def _close(self): # TODO: This never gets called except in tests. Do this better, like by having an explicit life cycle for demodulators. self.__process.loseConnection() @exported_value(type=BandShape, changes='never') def get_band_shape(self): """implements IDemodulator""" if self.__band_filter: return self.__band_filter.get_shape() else: # TODO Reuse UnselectiveAMDemodulator's approach to this return BandShape(stop_low=0, pass_low=0, pass_high=0, stop_high=0, markers={}) def get_output_type(self): """implements IDemodulator""" return no_signal