def _ConstantVFOCell(value): value = float(value) return LooseCell(key='freq', value=value, ctor=Range([(value, value)]), writable=False, persists=False)
def test_vfos(self): d = merge_devices([ Device(vfo_cell=_ConstantVFOCell(1)), Device(vfo_cell=LooseCell( value=0, type=RangeT([(10, 20)]), writable=True)) ]) self.assertTrue(d.get_vfo_cell().isWritable())
def AudioDevice( rx_device='', # may be used positionally, not recommented tx_device=None, name=None, sample_rate=44100, quadrature_as_stereo=False): rx_device = str(rx_device) if tx_device is not None: tx_device = str(tx_device) if name is None: full_name = u'Audio ' + rx_device if tx_device is not None: full_name += '/' + tx_device else: full_name = unicode(name) rx_driver = _AudioRXDriver(device_name=rx_device, sample_rate=sample_rate, quadrature_as_stereo=quadrature_as_stereo) if tx_device is not None: tx_driver = _AudioTXDriver(device_name=tx_device, sample_rate=sample_rate, quadrature_as_stereo=quadrature_as_stereo) else: tx_driver = nullExportedState return Device(name=full_name, vfo_cell=LooseCell(key='freq', value=0.0, ctor=Range([(0.0, 0.0)]), writable=True, persists=False), rx_driver=rx_driver, tx_driver=tx_driver)
def setUp(self): self.lc = LooseCell(value=0, type=RangeT([(-100, 100)])) self.delta = 1 self.vc = ViewCell(base=self.lc, get_transform=lambda x: x + self.delta, set_transform=lambda x: x - self.delta, type=int)
def __init__(self, adapter, freq): self.__adapter = adapter self.__freq_cell = LooseCell( value=freq, type=float, persists=False, writable=False)
def __init_center_cell(self): base_freq_cell = self.__rx_main.state()[_FREQ_CELL_KEY] mode_cell = self.__rx_main.state()['MD'] sidetone_cell = self.state()['CW'] iq_offset_cell = LooseCell(key='iq_offset', value=0.0, type=float) self.__iq_center_cell = ViewCell( base=base_freq_cell, get_transform=lambda x: x + iq_offset_cell.get(), set_transform=lambda x: x - iq_offset_cell.get(), key=_FREQ_CELL_KEY, type=base_freq_cell.type(), # runtime variable... writable=True, persists=base_freq_cell.metadata().persists) def changed_iq(_value=None): # TODO this is KX3-specific mode = mode_cell.get() if mode == 'CW': iq_offset = sidetone_cell.get() elif mode == 'CW-REV': iq_offset = -sidetone_cell.get() elif mode == 'AM' or mode == 'FM': iq_offset = 11000.0 else: # USB, LSB, other iq_offset = 0.0 iq_offset_cell.set(iq_offset) self.__iq_center_cell.changed_transform() # TODO bad practice mode_cell._subscribe_immediate(changed_iq) sidetone_cell._subscribe_immediate(changed_iq) changed_iq()
def _ConstantVFOCell(value): value = float(value) return LooseCell( value=value, type=RangeT([(value, value)]), writable=False, persists=False)
def setUp(self): self.lc = LooseCell(value=0, key='a', ctor=int) self.vc = ViewCell(base=self.lc, get_transform=lambda x: x + 1, set_transform=lambda x: x - 1, key='b', ctor=int)
def _RetuningTestDevice(freq, has_dc_offset): return Device( rx_driver=_RetuningTestRXDriver(has_dc_offset), vfo_cell=LooseCell( value=freq, type=RangeT([(-1e9, 1e9)]), # TODO kludge magic numbers writable=True, persists=False))
def SimulatedDevice(name='Simulated RF', freq=0.0): return Device(name=name, vfo_cell=LooseCell(key='freq', value=freq, ctor=Range([(freq, freq)]), writable=True, persists=False), rx_driver=_SimulatedRXDriver(name))
def __init__(self, lime_block): self.__lime_block = lime_block self.__vfo_cell = LooseCell(value=0.0, type=RangeT([(10e6, 3500e6)], strict=False, unit=units.Hz), writable=True, persists=True, post_hook=self.__set_freq)
def _cells(self, send, encoding): # TODO: Autogenerate unique keys instead of requiring __name to be unique. yield self.__name, LooseCell( type=self.__type, value=u'', writable=True, persists=True, post_hook=lambda value: send(unicode(value).encode(encoding)), label=self.__name)
def setUp(self): self.lc = LooseCell(value=0, type=RangeT([(-100, 100)]), writable=True) self.delta = 1 self.vc = ViewCell(base=self.lc, get_transform=lambda x: x + self.delta, set_transform=lambda x: x - self.delta, type=int, writable=True, interest_tracker=LoopbackInterestTracker())
def _install_cells(self, callback, send, encoding): callback( LooseCell( key=self.__name, type=self.__type, value=u'', writable=True, persists=True, post_hook=lambda value: send(unicode(value).encode(encoding))))
def __init__(self): self.messages = [] # 12,345,678 Hz, all the time, every day. self.__absolute_frequency_cell = LooseCell(value=12345678, type=float, writable=False, persists=False) verifyObject(IDemodulatorContext, self) # Ensure we are a good fake.
def __init__(self, signal_type=None, enable_scope=False, freq_resolution=4096, time_length=2048, window_type=windows.WIN_BLACKMAN_HARRIS, frame_rate=30.0, input_center_freq=0.0, paused=False, context=None): assert isinstance(signal_type, SignalType) assert context is not None itemsize = signal_type.get_itemsize() gr.hier_block2.__init__( self, type(self).__name__, gr.io_signature(1, 1, itemsize), gr.io_signature(0, 0, 0), ) # constant parameters self.__power_offset = 40 # TODO autoset or controllable self.__itemsize = itemsize self.__context = context self.__enable_scope = enable_scope # settable parameters self.__signal_type = signal_type self.__freq_resolution = int(freq_resolution) self.__time_length = int(time_length) self.__window_type = _window_type_enum(window_type) self.__frame_rate = float(frame_rate) self.__input_center_freq = float(input_center_freq) self.__paused = bool(paused) # interest tracking # this is indirect because we ignore interest when paused self.__interested_cell = LooseCell(type=bool, value=False, writable=False, persists=False) self.__has_subscriptions = False self.__interest = InterestTracker(self.__cell_interest_callback) self.__fft_queue = gr.msg_queue() self.__scope_queue = gr.msg_queue() # stuff created by __do_connect self.__gate = None self.__fft_sink = None self.__scope_sink = None self.__frame_dec = None self.__frame_rate_to_decimation_conversion = 0.0 self.__do_connect()
def SimulatedDevice(name='Simulated RF', freq=0.0, allow_tuning=False): return Device( name=name, vfo_cell=LooseCell( key='freq', value=freq, ctor=Range([(-1e9, 1e9)]) if allow_tuning else Range([(freq, freq)]), # TODO kludge magic numbers writable=True, persists=False), rx_driver=_SimulatedRXDriver(name))
def _install_cells(self, callback, send, encoding): callback( LooseCell( # TODO: Autogenerate unique keys instead of requiring __name to be unique. key=self.__name, type=self.__type, value=u'', writable=True, persists=True, post_hook=lambda value: send(unicode(value).encode(encoding)), label=self.__name))
def make_cell(self, protocol, is_sub): key = self.__command_name def send(value): protocol.send_command( _format_command(key, self.__syntax.format(value), is_sub=is_sub)) if self.__has_sub == (is_sub is not None): return key, LooseCell(post_hook=send, **self.__cell_kwargs)
def _install_cell(self, name, is_level, writable, callback, caps): # this is a function for the sake of the closure variables if name == 'Frequency': cell_name = 'freq' # consistency with our naming scheme elsewhere, also IHasFrequency else: cell_name = name if is_level: # TODO: Use range info from hamlib if available if name == 'STRENGTH level': vtype = Range([(-54, 50)], strict=False) elif name == 'SWR level': vtype = Range([(1, 30)], strict=False) elif name == 'RFPOWER level': vtype = Range([(0, 100)], strict=False) else: vtype = Range([(-10, 10)], strict=False) elif name == 'Mode' or name == 'TX Mode': # kludge vtype = Enum({x: x for x in caps['Mode list'].strip().split(' ')}) elif name == 'VFO' or name == 'TX VFO': vtype = Enum({x: x for x in caps['VFO list'].strip().split(' ')}) else: vtype = self._info[name] def updater(strval): try: if vtype is bool: value = bool(int(strval)) else: value = vtype(strval) except ValueError: value = unicode(strval) cell.set_internal(value) def actually_write_value(value): if vtype is bool: self._ehs_set(name, str(int(value))) else: self._ehs_set(name, str(vtype(value))) cell = LooseCell( key=cell_name, value='placeholder', type=vtype, writable=writable, persists=False, post_hook=actually_write_value, label=name) # TODO: supply label values from _info table self._cell_updaters[name] = updater updater(self._ehs_get(name)) callback(cell)
def receive(self, message_wrapper): """Implements ITelemetryObject.""" self.__last_heard_time = message_wrapper.receive_time for k, v in message_wrapper.message.iteritems(): if _message_field_is_id.get(k, False) or k == u'time': continue if k not in self.__cells: self.__cells[k] = LooseCell(key=k, value=None, type=object, writable=False, persists=False) self.__cells[k].set_internal(v)
def SimulatedDevice(name='Simulated RF', freq=0.0, allow_tuning=False): rx_driver = _SimulatedRXDriver(name) return Device( name=name, vfo_cell=LooseCell( key='freq', value=freq, type=RangeT([(-1e9, 1e9)]) if allow_tuning else RangeT( [(freq, freq)]), # TODO kludge magic numbers writable=True, persists=False, post_hook=rx_driver._set_sim_freq), rx_driver=rx_driver)
def make_cell(self, protocol, is_sub): cmd = 'FB' if is_sub else 'FA' def send_vfo(value): protocol.send_command( _format_command(cmd, self.__syntax.format(value))) if is_sub is not None: return _FREQ_CELL_KEY, LooseCell(value=0, type=self.__syntax.default_type(), writable=True, persists=False, post_hook=send_vfo)
def __init__(self, signal_type=None, enable_scope=False, freq_resolution=4096, time_length=2048, frame_rate=30.0, input_center_freq=0.0, paused=False, context=None): assert isinstance(signal_type, SignalType) assert context is not None itemsize = signal_type.get_itemsize() gr.hier_block2.__init__( self, type(self).__name__, gr.io_signature(1, 1, itemsize), gr.io_signature(0, 0, 0), ) # constant parameters self.__power_offset = 40 # TODO autoset or controllable self.__itemsize = itemsize self.__context = context self.__enable_scope = enable_scope # settable parameters self.__signal_type = signal_type self.__freq_resolution = int(freq_resolution) self.__time_length = int(time_length) self.__frame_rate = float(frame_rate) self.__input_center_freq = float(input_center_freq) self.__paused = bool(paused) self.__interested_cell = LooseCell(key='interested', type=bool, value=False, writable=False, persists=False) # blocks self.__gate = None self.__fft_sink = None self.__scope_sink = None self.__scope_chunker = None self.__before_fft = None self.__logpwrfft = None self.__overlapper = None self.__rebuild() self.__connect()
def SimulatedDevice(name='Simulated RF', freq=0.0, allow_tuning=False): """ See documentation in shinysdr/i/webstatic/manual/configuration.html. """ rx_driver = _SimulatedRXDriver(name) return Device( name=name, vfo_cell=LooseCell( value=freq, type=RangeT([(-1e9, 1e9)]) if allow_tuning else RangeT( [(freq, freq)]), # TODO kludge magic numbers writable=True, persists=False, post_hook=rx_driver._set_sim_freq), rx_driver=rx_driver)
def __init__(self, profile, correction_ppm, osmo_block): self.__profile = profile self.__correction_ppm = correction_ppm self.__osmo_block = osmo_block self.__vfo_cell = LooseCell( key='freq', value=0.0, # TODO: Eventually we'd like to be able to make the freq range vary dynamically with the correction setting type=convert_osmosdr_range(osmo_block.get_freq_range(ch), strict=False, transform=self.from_hardware_freq, add_zero=profile.e4000), writable=True, persists=True, post_hook=self.__set_freq)
def test_specify_all_metadata(self): # using LooseCell as an arbitrary concrete subclass cell = LooseCell( value=0, type=int, persists=False, # the non-default value label='mylabel', description='mydescription', sort_key='mysortkey') self.assertEqual(cell.metadata().value_type, to_value_type(int)) self.assertEqual(cell.metadata().persists, False) self.assertEqual(cell.metadata().naming, EnumRow( label='mylabel', description='mydescription', sort_key='mysortkey'))
def AudioDevice( rx_device=b'', # may be used positionally, not recommented tx_device=None, name=None, sample_rate=44100, channel_mapping=None, usable_bandwidth=None, _module=gr_audio): # parameter for testing only """System audio ("sound card") device. See documentation in shinysdr/i/webstatic/manual/configuration.html. """ rx_device = str(rx_device) if tx_device is not None: tx_device = str(tx_device) channel_mapping = _coerce_channel_mapping(channel_mapping) if name is None: full_name = u'Audio ' + unicode(rx_device) if tx_device is not None: full_name += '/' + unicode(tx_device) else: full_name = unicode(name) rx_driver = _AudioRXDriver( device_name=rx_device, sample_rate=sample_rate, channel_mapping=channel_mapping, usable_bandwidth=usable_bandwidth, audio_module=_module) if tx_device is not None: tx_driver = _AudioTXDriver( device_name=tx_device, sample_rate=sample_rate, channel_mapping=channel_mapping, audio_module=_module) else: tx_driver = nullExportedState return Device( name=full_name, vfo_cell=LooseCell( value=0.0, type=RangeT([(0.0, 0.0)]), writable=True, persists=False), rx_driver=rx_driver, tx_driver=tx_driver)
def __init_center_cell(self): base_freq_cell = self.__rx_main.state()[_FREQ_CELL_KEY] mode_cell = self.__rx_main.state()['MD'] sidetone_cell = self.state()['CW'] submode_cell = self.state()['DT'] iq_offset_cell = LooseCell(value=0.0, type=float, writable=True) self.__iq_center_cell = ViewCell( base=base_freq_cell, get_transform=lambda x: x + iq_offset_cell.get(), set_transform=lambda x: x - iq_offset_cell.get(), type=base_freq_cell.type(), # runtime variable... writable=True, persists=base_freq_cell.metadata().persists) def changed_iq(_value=None): # TODO this is KX3-specific mode = mode_cell.get() if mode == 'CW': iq_offset = sidetone_cell.get() elif mode == 'CW-REV': iq_offset = -sidetone_cell.get() elif mode == 'AM' or mode == 'FM': iq_offset = 11000.0 elif mode == 'DATA' or mode == 'DATA-REV': submode = submode_cell.get() if submode == 0: # "DATA A", SSB with less processing iq_offset = 0.0 # ??? elif submode == 1: # "AFSK A", SSB with RTTY style filter iq_offset = 0.0 # ??? elif submode == 2: # "FSK D", RTTY iq_offset = 900.0 elif submode == 3: # "PSK D", PSK31 iq_offset = 1000.0 # I think so... else: iq_offset = 0 # fallback if mode == 'DATA-REV': iq_offset = -iq_offset else: # USB, LSB, other iq_offset = 0.0 iq_offset_cell.set(iq_offset) self.__iq_center_cell.changed_transform() # TODO bad practice mode_cell._subscribe_immediate(changed_iq) sidetone_cell._subscribe_immediate(changed_iq) submode_cell._subscribe_immediate(changed_iq) changed_iq()
def SimulatedDeviceForTest(name='Simulated RF', freq=0.0, allow_tuning=False, add_transmitters=False): """Identical to SimulatedDevice except that the defaults are arranged to be minimal for fast testing rather than to provide a rich simulation.""" rx_driver = _SimulatedRXDriver(name, add_transmitters=add_transmitters) return Device( name=name, vfo_cell=LooseCell( value=freq, type=RangeT([(-1e9, 1e9)]) if allow_tuning else RangeT( [(freq, freq)]), # TODO kludge magic numbers writable=True, persists=False, post_hook=rx_driver._set_sim_freq), rx_driver=rx_driver)