def __on_refresh(self, _event):
dlg = wx.BusyInfo('Please wait...')
try:
if self.device.isDevice:
sdr = rtlsdr.RtlSdr(self.device.indexRtl)
else:
sdr = RtlTcp(self.device.server, self.device.port, None)
sdr.set_sample_rate(SAMPLE_RATE)
sdr.set_center_freq(self.spinFreq.GetValue() * 1e6)
sdr.set_gain(self.spinGain.GetValue())
capture = sdr.read_samples(2 ** 21)
sdr.close()
except IOError as error:
if self.device.isDevice:
message = error.message
else:
message = error
dlg.Destroy()
dlg = wx.MessageDialog(self,
'Capture failed:\n{}'.format(message),
'Error',
wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return
self.__plot(capture)
dlg.Destroy()
class ThreadScan(threading.Thread):
def __init__(self, notify, queue, sdr, settings, device, samples, isCal):
threading.Thread.__init__(self)
self.name = 'Scan'
self.notify = notify
self.queue = queue
self.sdr = sdr
self.fstart = settings.start * 1e6
self.fstop = settings.stop * 1e6
self.samples = int(samples)
self.isCal = isCal
self.indexRtl = settings.indexRtl
self.isDevice = settings.devicesRtl[device].isDevice
self.server = settings.devicesRtl[device].server
self.port = settings.devicesRtl[device].port
self.gain = settings.devicesRtl[device].gain
self.lo = settings.devicesRtl[device].lo * 1e6
self.offset = settings.devicesRtl[device].offset
self.cancel = False
post_event(self.notify, EventThread(Event.STARTING))
steps = int((self.__f_stop() - self.__f_start()) / self.__f_step())
post_event(self.notify, EventThread(Event.STEPS, steps))
self.start()
def __f_start(self):
return self.fstart - self.offset - BANDWIDTH
def __f_stop(self):
return self.fstop + self.offset + BANDWIDTH * 2
def __f_step(self):
return BANDWIDTH / 2
def __rtl_setup(self):
if self.sdr is not None:
return
tuner = 0
if self.isDevice:
try:
self.sdr = rtlsdr.RtlSdr(self.indexRtl)
self.sdr.set_sample_rate(SAMPLE_RATE)
self.sdr.set_gain(self.gain)
tuner = self.sdr.get_tuner_type()
except IOError as error:
post_event(self.notify,
EventThread(Event.ERROR, 0, error.message))
else:
try:
self.sdr = RtlTcp(self.server, self.port, self.notify)
self.sdr.set_sample_rate(SAMPLE_RATE)
self.sdr.set_gain(self.gain)
tuner = self.sdr.get_tuner_type()
except IOError as error:
post_event(self.notify, EventThread(Event.ERROR, 0, error))
return tuner
def run(self):
tuner = self.__rtl_setup()
if self.sdr is None:
return
post_event(self.notify, EventThread(Event.INFO, None, tuner))
freq = self.__f_start()
timeStamp = math.floor(time.time())
while freq <= self.__f_stop():
if self.cancel:
post_event(self.notify, EventThread(Event.STOPPED))
self.rtl_close()
return
try:
scan = self.rtl_scan(freq)
if len(scan):
self.queue.put([freq, (timeStamp, scan)])
post_event(self.notify, EventThread(Event.DATA))
else:
post_event(
self.notify,
EventThread(Event.ERROR, 0, 'No samples returned'))
return
except (AttributeError, MemoryError, TypeError) as error:
post_event(self.notify,
EventThread(Event.ERROR, 0, error.message))
return
except (IOError, OSError) as error:
if self.sdr is not None:
self.rtl_close()
post_event(self.notify,
EventThread(Event.ERROR, 0, error.message))
return
freq += self.__f_step()
post_event(self.notify, EventThread(Event.FINISHED, 0, None))
if self.isCal:
post_event(self.notify, EventThread(Event.CAL))
def abort(self):
self.cancel = True
def rtl_scan(self, freq):
self.sdr.set_center_freq(freq + self.lo)
capture = self.sdr.read_samples(self.samples)
return capture
def rtl_close(self):
self.sdr.close()
def get_sdr(self):
return self.sdr