示例#1
0
    def __make_demodulator(self, mode, state):
        '''Returns the demodulator.'''

        t0 = time.time()
        
        mode_def = lookup_mode(mode)
        if mode_def is None:
            # TODO: Better handling, like maybe a dummy demod
            raise ValueError('Unknown mode: ' + mode)
        clas = mode_def.demod_class

        state = state.copy()  # don't modify arg
        if 'mode' in state: del state['mode']  # don't switch back to the mode we just switched from
        
        facet = ContextForDemodulator(self)
        
        init_kwargs = dict(
            mode=mode,
            input_rate=self.__get_device().get_rx_driver().get_output_type().get_sample_rate(),
            context=facet)
        demodulator = unserialize_exported_state(
            ctor=clas,
            state=state,
            kwargs=init_kwargs)
        
        # until _enabled, ignore any callbacks resulting from unserialization calling setters
        facet._enabled = True
        log.msg('Constructed %s demodulator: %i ms.' % (mode, (time.time() - t0) * 1000))
        return demodulator
示例#2
0
    def __make_demodulator(self, mode, state):
        """Returns the demodulator."""

        t0 = time.time()

        mode_def = lookup_mode(mode)
        if mode_def is None:
            # TODO: Better handling, like maybe a dummy demod
            raise ValueError('Unknown mode: ' + mode)
        clas = mode_def.demod_class

        state = state.copy()  # don't modify arg
        if 'mode' in state:
            del state[
                'mode']  # don't switch back to the mode we just switched from

        facet = ContextForDemodulator(self)

        init_kwargs = dict(mode=mode,
                           input_rate=self.__get_device().get_rx_driver().
                           get_output_type().get_sample_rate(),
                           context=facet)
        demodulator = unserialize_exported_state(ctor=clas,
                                                 state=state,
                                                 kwargs=init_kwargs)

        # until _enabled, ignore any callbacks resulting from unserialization calling setters
        facet._enabled = True
        log.msg('Constructed %s demodulator: %i ms.' %
                (mode, (time.time() - t0) * 1000))
        return demodulator
示例#3
0
    def __make_demodulator(self, mode, state):
        '''Returns the demodulator.'''

        mode_def = lookup_mode(mode)
        if mode_def is None:
            # TODO: Better handling, like maybe a dummy demod
            raise ValueError('Unknown mode: ' + mode)
        clas = mode_def.demod_class

        state = state.copy()  # don't modify arg
        if 'mode' in state:
            del state[
                'mode']  # don't switch back to the mode we just switched from

        facet = ContextForDemodulator(self)

        init_kwargs = dict(mode=mode,
                           input_rate=self.input_rate,
                           context=facet)
        for sh_key, sh_ctor in mode_def.shared_objects.iteritems():
            init_kwargs[sh_key] = self.context.get_shared_object(sh_ctor)
        demodulator = unserialize_exported_state(ctor=clas,
                                                 state=state,
                                                 kwargs=init_kwargs)

        # until _enabled, ignore any callbacks resulting from unserialization calling setters
        facet._enabled = True
        return demodulator
示例#4
0
    def __make_demodulator(self, mode, state):
        """Returns the demodulator."""

        t0 = time.time()

        mode_def = lookup_mode(mode)
        if mode_def is None:
            # TODO: Better handling, like maybe a dummy demod
            raise ValueError("Unknown mode: " + mode)
        clas = mode_def.demod_class

        state = state.copy()  # don't modify arg
        if "mode" in state:
            del state["mode"]  # don't switch back to the mode we just switched from

        facet = ContextForDemodulator(self)

        init_kwargs = dict(
            mode=mode, input_rate=self.__get_device().get_rx_driver().get_output_type().get_sample_rate(), context=facet
        )
        for sh_key, sh_ctor in mode_def.shared_objects.iteritems():
            init_kwargs[sh_key] = self.context.get_shared_object(sh_ctor)
        demodulator = unserialize_exported_state(ctor=clas, state=state, kwargs=init_kwargs)

        # until _enabled, ignore any callbacks resulting from unserialization calling setters
        facet._enabled = True
        log.msg("Constructed %s demodulator: %i ms." % (mode, (time.time() - t0) * 1000))
        return demodulator
示例#5
0
	def __make_demodulator(self, mode, state):
		'''Returns the demodulator.'''

		mode_def = lookup_mode(mode)
		if mode_def is None:
			# TODO: Better handling, like maybe a dummy demod
			raise ValueError('Unknown mode: ' + mode)
		clas = mode_def.demod_class

		state = state.copy()  # don't modify arg
		if 'mode' in state: del state['mode']  # don't switch back to the mode we just switched from
		
		facet = ContextForDemodulator(self)
		
		init_kwargs = dict(
			mode=mode,
			input_rate=self.input_rate,
			context=facet)
		for sh_key, sh_ctor in mode_def.shared_objects.iteritems():
			init_kwargs[sh_key] = self.context.get_shared_object(sh_ctor)
		demodulator = unserialize_exported_state(
			ctor=clas,
			state=state,
			kwargs=init_kwargs)
		
		# until _enabled, ignore any callbacks resulting from unserialization calling setters
		facet._enabled = True
		return demodulator
示例#6
0
    def __init__(self,
                 mode,
                 input_rate=0,
                 input_center_freq=0,
                 rec_freq=100.0,
                 audio_destination=None,
                 audio_gain=-6,
                 audio_pan=0,
                 audio_channels=0,
                 context=None):
        assert input_rate > 0
        assert audio_channels == 1 or audio_channels == 2
        assert audio_destination is not None
        gr.hier_block2.__init__(
            # str() because insists on non-unicode
            self,
            str('%s receiver' % (mode, )),
            gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
            gr.io_signature(audio_channels, audio_channels,
                            gr.sizeof_float * 1),
        )

        if lookup_mode(mode) is None:
            # TODO: communicate back to client if applicable
            log.msg('Unknown mode %r in Receiver(); using AM' % (mode, ))
            mode = 'AM'

        # Provided by caller
        self.context = context
        self.input_rate = input_rate
        self.input_center_freq = input_center_freq
        self.__audio_channels = audio_channels

        # Simple state
        self.mode = mode
        self.rec_freq = rec_freq
        self.audio_gain = audio_gain
        self.audio_pan = min(1, max(-1, audio_pan))
        self.__audio_destination = audio_destination

        # Blocks
        self.__rotator = blocks.rotator_cc()
        self.demodulator = self.__make_demodulator(mode, {})
        self.__update_demodulator_info()
        self.__audio_gain_blocks = [
            blocks.multiply_const_ff(0.0)
            for _ in xrange(self.__audio_channels)
        ]
        self.probe_audio = analog.probe_avg_mag_sqrd_f(
            0, alpha=10.0 / 44100)  # TODO adapt to output audio rate

        # Other internals
        self.__last_output_type = None

        self.__update_rotator(
        )  # initialize rotator, also in case of __demod_tunable
        self.__update_audio_gain()
        self.__do_connect()
示例#7
0
		def add_modulator(freq, key, mode, **kwargs):
			mode_def = lookup_mode(mode)
			if mode_def is None:  # missing plugin, say
				return
			modulator = mode_def.mod_class(**kwargs)
			tx = _SimulatedTransmitter(modulator, audio_rate, rf_rate, freq)
			
			self.connect(audio_signal, tx)
			signals.append(tx)
			self._transmitters[key] = tx
示例#8
0
 def add_modulator(freq, key, mode, **kwargs):
     mode_def = lookup_mode(mode)
     if mode_def is None:  # missing plugin, say
         return
     modulator = mode_def.mod_class(**kwargs)
     tx = _SimulatedTransmitter(modulator, audio_rate, rf_rate, freq)
     
     self.connect(audio_signal, tx)
     signals.append(tx)
     self._transmitters[key] = tx
示例#9
0
    def __init__(
        self,
        mode,
        rec_freq=100.0,
        audio_destination=None,
        device_name=None,
        audio_gain=-6,
        audio_pan=0,
        audio_channels=0,
        context=None,
    ):
        assert audio_channels == 1 or audio_channels == 2
        assert audio_destination is not None
        assert device_name is not None
        gr.hier_block2.__init__(
            # str() because insists on non-unicode
            self,
            str("%s receiver" % (mode,)),
            gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
            gr.io_signature(audio_channels, audio_channels, gr.sizeof_float * 1),
        )

        if lookup_mode(mode) is None:
            # TODO: communicate back to client if applicable
            log.msg("Unknown mode %r in Receiver(); using AM" % (mode,))
            mode = "AM"

        # Provided by caller
        self.context = context
        self.__audio_channels = audio_channels

        # cached info from device
        self.__device_name = device_name

        # Simple state
        self.mode = mode
        self.rec_freq = rec_freq
        self.audio_gain = audio_gain
        self.audio_pan = min(1, max(-1, audio_pan))
        self.__audio_destination = audio_destination

        # Blocks
        self.__rotator = blocks.rotator_cc()
        self.__demodulator = self.__make_demodulator(mode, {})
        self.__update_demodulator_info()
        self.__audio_gain_blocks = [blocks.multiply_const_ff(0.0) for _ in xrange(self.__audio_channels)]
        self.probe_audio = analog.probe_avg_mag_sqrd_f(0, alpha=10.0 / 44100)  # TODO adapt to output audio rate

        # Other internals
        self.__last_output_type = None

        self.__update_rotator()  # initialize rotator, also in case of __demod_tunable
        self.__update_audio_gain()
        self.__do_connect(reason=u"initialization")
示例#10
0
 def __init__(self, mode, state=None):
     # TODO: Refactor things so that we can take the demod ctor rather than a mode string
     if state is None:
         state = {}
     mode_def = lookup_mode(mode)
     if mode_def is None:
         raise Exception('No such mode is registered: ' + repr(mode))
     # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup
     self.__top = Top(devices={'s1': SimulatedDevice()})
     (_, receiver) = self.__top.add_receiver(mode, key='a', state=state)
     self.__demodulator = receiver.get_demodulator()
     if not isinstance(self.__demodulator, mode_def.demod_class):
         raise Exception('Demodulator not of expected class: ' + repr(self.__demodulator))
     self.__top.start()  # TODO overriding internals
示例#11
0
 def __init__(self, mode, state=None):
     # TODO: Refactor things so that we can take the demod ctor rather than a mode string
     if state is None:
         state = {}
     mode_def = lookup_mode(mode)
     if mode_def is None:
         raise Exception('No such mode is registered: ' + repr(mode))
     # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup
     self.__top = Top(devices={'s1': SimulatedDevice()})
     (_, receiver) = self.__top.add_receiver(mode, key='a', state=state)
     self.__demodulator = receiver.get_demodulator()
     if not isinstance(self.__demodulator, mode_def.demod_class):
         raise Exception('Demodulator not of expected class: ' + repr(self.__demodulator))
     self.__top.start()  # TODO overriding internals
示例#12
0
 def add_modulator(freq, key, mode_or_modulator_ctor, **kwargs):
     if isinstance(mode_or_modulator_ctor, type):
         mode = None
         ctor = mode_or_modulator_ctor
     else:
         mode = mode_or_modulator_ctor
         mode_def = lookup_mode(mode)
         if mode_def is None:  # missing plugin, say
             return
         ctor = mode_def.mod_class
     context = None  # TODO implement context
     modulator = ctor(context=context, mode=mode, **kwargs)
     tx = _SimulatedTransmitter(modulator, audio_rate, rf_rate, freq)
     
     self.connect(audio_signal, tx)
     signals.append(tx)
     self.__transmitters[key] = tx
示例#13
0
        def add_modulator(freq, key, mode_or_modulator_ctor, **kwargs):
            if isinstance(mode_or_modulator_ctor, type):
                mode = None
                ctor = mode_or_modulator_ctor
            else:
                mode = mode_or_modulator_ctor
                mode_def = lookup_mode(mode)
                if mode_def is None:  # missing plugin, say
                    return
                ctor = mode_def.mod_class
            context = None  # TODO implement context
            modulator = ctor(context=context, mode=mode, **kwargs)
            tx = _SimulatedTransmitter(modulator, audio_rate, rf_rate, freq)

            self.connect(audio_signal, tx)
            signals.append(tx)
            self.__transmitters[key] = tx
示例#14
0
    def __init__(self,
                 mode,
                 freq_absolute=100.0,
                 freq_relative=None,
                 freq_linked_to_device=False,
                 audio_destination=None,
                 device_name=None,
                 audio_gain=-6,
                 audio_pan=0,
                 audio_channels=0,
                 context=None):
        assert audio_channels == 1 or audio_channels == 2
        assert audio_destination is not None
        assert device_name is not None
        gr.hier_block2.__init__(
            # str() because insists on non-unicode
            self,
            str('%s receiver' % (mode, )),
            gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
            gr.io_signature(audio_channels, audio_channels,
                            gr.sizeof_float * 1),
        )

        if lookup_mode(mode) is None:
            # TODO: communicate back to client if applicable
            log.msg('Unknown mode %r in Receiver(); using AM' % (mode, ))
            mode = 'AM'

        # Provided by caller
        self.context = context
        self.__audio_channels = audio_channels

        # cached info from device
        self.__device_name = device_name

        # Simple state
        self.mode = mode
        self.audio_gain = audio_gain
        self.audio_pan = min(1, max(-1, audio_pan))
        self.__audio_destination = audio_destination

        # Receive frequency.
        self.__freq_linked_to_device = bool(freq_linked_to_device)
        if self.__freq_linked_to_device and freq_relative is not None:
            self.__freq_relative = float(freq_relative)
            self.__freq_absolute = self.__freq_relative + self.__get_device(
            ).get_freq()
        else:
            self.__freq_absolute = float(freq_absolute)
            self.__freq_relative = self.__freq_absolute - self.__get_device(
            ).get_freq()

        # Blocks
        self.__rotator = blocks.rotator_cc()
        self.__demodulator = self.__make_demodulator(mode, {})
        self.__update_demodulator_info()
        self.__audio_gain_blocks = [
            blocks.multiply_const_ff(0.0)
            for _ in xrange(self.__audio_channels)
        ]
        self.probe_audio = analog.probe_avg_mag_sqrd_f(
            0, alpha=10.0 / 44100)  # TODO adapt to output audio rate

        # Other internals
        self.__last_output_type = None

        self.__update_rotator(
        )  # initialize rotator, also in case of __demod_tunable
        self.__update_audio_gain()
        self.__do_connect(reason=u'initialization')