def on_refresh(self, _event): plot = [] sdr = rtlsdr.RtlSdr(int(self.index)) sdr.set_sample_rate(SAMPLE_RATE) sdr.set_center_freq(self.spinFreq.GetValue() * 1e6) sdr.set_gain(GAIN) capture = sdr.read_samples(2**18) powers, freqs = matplotlib.mlab.psd(capture, NFFT=NFFT, Fs=SAMPLE_RATE / 1e6, window=WINDOW) for x, y in itertools.izip(freqs, powers): x = x * SAMPLE_RATE / 2e6 plot.append((x, y)) plot.sort() x, y = numpy.transpose(plot) self.axes.clear() self.band1 = None self.band2 = None self.axes.set_xlabel("Frequency (MHz)") self.axes.set_ylabel('Level (dB)') self.axes.set_yscale('log') self.axes.plot(x, y, linewidth=0.4) self.draw_limits()
def run(self): """ Starts the analyzing process and hands control flow over to rtlsdr. """ signal.signal(signal.SIGTERM, self.handle_signal) signal.signal(signal.SIGINT, self.handle_signal) # logging levels increase in steps of 10, start with warning logging_level = max(0, logging.WARN - (self.verbose * 10)) logging.basicConfig(level=logging_level) # setup sdr sdr = rtlsdr.RtlSdr(self.device_index) sdr.sample_rate = self.sample_rate sdr.center_freq = self.center_freq sdr.gain = float(self.gain) sdr.set_agc_mode(False) self.sdr = sdr signal.signal(signal.SIGALRM, self.handle_signal) signal.alarm(self.sdr_timeout_s) # start sdr sampling self.sdr.read_samples_async(self.process_samples, self.sdr_callback_length)
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_manual_gain_enabled(1) 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.RtlTcp(self.server, self.port, self.notify) self.sdr.set_sample_rate(SAMPLE_RATE) self.sdr.set_manual_gain_enabled(1) 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 __init__(self, stationMHz): self.sdr = rtlsdr.RtlSdr() self.validsGains = self.sdr.get_gains() self.indexGain = 10 self.f_offset = 250000 # Desplazamiento para capturar self.f_station = stationMHz # Frecuencia de radio self.dec_rate = int(FS / F_BW) self.fs_y = FS / (self.dec_rate) self.coef = remez(N_TRAPS, [0, F_BW, F_BW * 1.4, FS / 2], [1, 0], Hz=FS) self.expShift = (-1.0j * 2.0 * np.pi * self.f_offset / FS) # Se configura los parametros self.dec_audio = int(self.fs_y / AUDIO_FREC) self.stream = sd.OutputStream(device='default', samplerate=int(self.fs_y / self.dec_audio), channels=1, dtype='float32') self.beginListening = 0 self.soundQueue = queue.Queue() self.samplesQueue = queue.Queue()
def __init__(self, opts, gpsp, devmod, settings): self.devnum = opts['devnum'] self.station_id = opts['station_id'] self.station_pass = opts['station_pass'] self.server_host = opts['server_host'] self.server_port = opts['server_port'] self.freqlist = opts['freqlist'] self.jobid = opts['uuid'] self.sdr = rtlsdr.RtlSdr(self.devnum) self.sdr.set_sample_rate(SAMPLE_RATE) self.sdr.set_manual_gain_enabled(1) ppm = opts['ppm'] if ppm != 0: self.sdr.freq_correction = ppm self.gpsp = gpsp self.devmod = devmod self.settings = settings self.gain = self.settings['gain'] self.sdr.set_gain(self.gain) self.numsamps = self.next_2_to_pow(int(DWELL * SAMPLE_RATE)) self.stoprequest = threading.Event() threading.Thread.__init__(self)
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()
def __init__(self, opt): self.opt = opt self.rtl = rtlsdr.RtlSdr() # Set up rtl-sdr dongle with options from command line. self.rtl.sample_rate = opt.sample_rate self.rtl.center_freq = opt.rtl_frequency self.rtl.set_gain(opt.rtl_gain) return
def run(self): self._sdr = rtlsdr.RtlSdr() self._sdr.set_sample_rate(SAMPLE_RATE) self.set_frequency(self._freq) cal = self._sdr.get_freq_correction() if self._cal != cal: self._sdr.set_freq_correction(self._cal) self._sdr.set_gain(self._gain) time.sleep(1) self._sdr.read_bytes_async(self.__capture, SAMPLES)
def __init__(self): super(rxSDR, self).__init__() self._delay = 10 self.daemon = True # Configure SDR parameters self.sdr = rtl.RtlSdr() self.setGain(gain) self.setFc(fc, "mhz") self.setFs(fs, "mhz") self.start()
def start_radio(self, freq, output): '''Uses rtlsdr module to connect to a SDR dongle and store output as a wav file. :output name of an output file :freq center frequency of reception ''' import rtlsdr if rtlsdr.STATUS==-1: self.put_log('Could not connect to radio. Dependencies not installed.') print 'Could not connect to radio. Dependencies not installed.' return self.radio = rtlsdr.RtlSdr(freq=freq, output=output) self.radio.start_radio()
def rtl_setup(self): sdr = None try: sdr = rtlsdr.RtlSdr(self.index) sdr.set_sample_rate(SAMPLE_RATE) sdr.set_gain(GAIN) except IOError as error: wx.PostEvent( self.notify, EventThreadStatus(THREAD_STATUS_ERROR, None, error.message)) return sdr
def capture(Tc, fo=88.7e6, fs=2.4e6, gain=40, device_index=0): # Setup SDR sdr = rtlsdr.RtlSdr(device_index) #create a RtlSdr object #sdr.get_tuner_type() sdr.sample_rate = fs sdr.center_freq = fo #sdr.gain = 'auto' sdr.gain = gain # Capture samples Nc = np.ceil(Tc * fs) x = sdr.read_samples(Nc) sdr.close() return x
def __init__(self, **kwargs): super(RtlReader, self).__init__() self.signal_buffer = [] # amplitude of the sample only self.sdr = rtlsdr.RtlSdr() self.sdr.sample_rate = sampling_rate self.sdr.center_freq = modes_frequency self.sdr.gain = "auto" self.debug = kwargs.get("debug", False) self.raw_pipe_in = None self.stop_flag = False self.noise_floor = 1e6 self.exception_queue = None
def run(**kwargs): sdr.tools.print_ignored_frequencies(kwargs["ignored_frequencies_ranges"]) sdr.tools.print_frequencies_ranges(kwargs["frequencies_ranges"]) sdr.tools.separator("scanning started") kwargs["frequencies_ranges"] = __filter_ranges(**kwargs) device = rtlsdr.RtlSdr() device.ppm_error = kwargs["ppm_error"] device.gain = kwargs["tuner_gain"] device.sample_rate = kwargs["bandwidth"] killer = application_killer.ApplicationKiller() while killer.is_running: __scan(device, **kwargs)
def run(**kwargs): sdr.tools.print_ignored_frequencies(kwargs["ignored_frequencies_ranges"]) sdr.tools.print_frequencies_ranges(kwargs["frequencies_ranges"]) sdr.tools.separator("scanning started") kwargs["frequencies_ranges"] = __filter_ranges(**kwargs) try: device = rtlsdr.RtlSdr() device.ppm_error = kwargs["ppm_error"] device.gain = kwargs["tuner_gain"] device.sample_rate = kwargs["bandwidth"] killer = application_killer.ApplicationKiller() while killer.is_running: __scan(device, **kwargs) except rtlsdr.rtlsdr.LibUSBError as e: logger = logging.getLogger("sdr") logger.critical("Device error, error message: " + str(e) + " quitting!") exit(1)
def __receive(self): self._receive = False events.Post(self._queue).status(events.STATUS_CAPTURE) try: if self._sdr is None: self._sdr = rtlsdr.RtlSdr( device_index=self._settings.recvIndex) self._sdr.set_sample_rate(SAMPLE_RATE) self._sdr.set_center_freq(self._settings.freq * 1e6) time.sleep(1) self._sdr.set_gain(self._settings.recvGain) cal = int(self._settings.recvCal) if cal != 0: self._sdr.set_freq_correction(cal) self._timeStamp = time.time() self._sdr.read_bytes_async(self.__capture, 2 * SAMPLE_RATE * SAMPLE_TIME / BLOCKS) if self._cancel: return events.Post(self._queue).status(events.STATUS_PROCESS) iq = stream_to_complex(self._capture) if self._cancel: return scan = Scan(SAMPLE_RATE, iq) frequencies = scan.search() if self._cancel: return detect = Detect(SAMPLE_RATE, iq, frequencies) collars = detect.search(self._settings.freq * 1e6) events.Post(self._queue).status(events.STATUS_IDLE) events.Post(self._queue).scan_done(collars=collars, timeStamp=self._timeStamp) except IOError as e: error = 'Capture failed: {}'.format(e.message) events.Post(self._queue).error(error)
def get_devices_rtl(currentDevices=None, statusBar=None): if statusBar is not None: statusBar.set_general("Refreshing device list...") if currentDevices is None: currentDevices = [] devices = [] count = rtlsdr.librtlsdr.rtlsdr_get_device_count() for dev in range(0, count): device = DeviceRTL() device.indexRtl = dev device.name = format_device_rtl_name( rtlsdr.librtlsdr.rtlsdr_get_device_name(dev)) buffer1 = (c_ubyte * 256)() buffer2 = (c_ubyte * 256)() serial = (c_ubyte * 256)() rtlsdr.librtlsdr.rtlsdr_get_device_usb_strings(dev, buffer1, buffer2, serial) device.serial = string_at(serial) try: sdr = rtlsdr.RtlSdr(dev) except IOError: continue device.gains = sdr.valid_gains_db device.calibration = 0.0 device.lo = 0.0 for conf in currentDevices: if conf.isDevice and device.name == conf.name and device.serial == conf.serial: device.set(conf) devices.append(device) for conf in currentDevices: if not conf.isDevice: devices.append(conf) if statusBar is not None: statusBar.set_general("") return devices
def on_refresh(self, _event): plot = [] dlg = wx.BusyInfo('Please wait...') try: sdr = rtlsdr.RtlSdr(int(self.index)) 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**18) except IOError as e: dlg.Destroy() dlg = wx.MessageDialog(self, 'Capture failed:\n{0}'.format(e.message), 'Error', wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return powers, freqs = matplotlib.mlab.psd(capture, NFFT=NFFT, Fs=SAMPLE_RATE / 1e6, window=WINDOW) for x, y in itertools.izip(freqs, powers): x = x * SAMPLE_RATE / 2e6 plot.append((x, y)) plot.sort() x, y = numpy.transpose(plot) self.axes.clear() self.band1 = None self.band2 = None self.axes.set_xlabel("Frequency (MHz)") self.axes.set_ylabel('Level (dB)') self.axes.set_yscale('log') self.axes.plot(x, y, linewidth=0.4) self.draw_limits() dlg.Destroy()
def __init__(self, fs, baseband, gain, callback): self._gain = gain self.fs = fs self.baseband = baseband self._callback = callback self._capture = (ctypes.c_ubyte * int(2 * SAMPLE_RATE * SAMPLE_TIME))() self._captureBlock = 0 print 'RTLSDR:' print '\tSample rate: {:.2f}MSPS'.format(fs / 1e6) print '\tFrequency: {:.2f}MHz'.format(baseband / 1e6) self._sdr = rtlsdr.RtlSdr() self._sdr.set_sample_rate(self.fs) if self._gain is not None: self._sdr.set_gain(self._gain) gain = self._sdr.get_gain() print '\tGain: {:.1f}dB'.format(gain) self._sdr.set_center_freq(self.baseband) time.sleep(1)
def testSdr(): sdr = rtlsdr.RtlSdr() radioQ = Queue.Queue() Qout = Queue.Queue() initRtlSdr(sdr, 105.3e6, 2.4e5, 22) getSamplesAsync(sdr, radioQ) p = pyaudio.PyAudio() play_t = threading.Thread(target=play_audio, args=(Qout, p, 48000.0)) play_t.start() dem = Demodulator(2.4e5, 80000.0, 48000.0, 16000.0) while (True): data = radioQ.get() audio = dem.fm_demodulate(data) #spectrogram(audio) Qout.put(audio)
def sdr_setup(sdr, fC, fS, gain): ''' Setup rtlsdr. Also skip few samples to avoid any junk, when it is settling. If there is a failure in setting up the rtlsdr, then it closes and reopens a new instance of rtlsdr. The same is returned to the caller, along with a success or failure boolean. ''' try: sdr.sample_rate = fS sdr.center_freq = fC sdr.gain = gain bOk = True samples = sdr.read_samples(16*1024) except: print("WARN:SetupSDR:FAILED: fC[{}] fS[{}] gain[{}]".format(fC, fS, gain)) sdr.close() sdr = rtlsdr.RtlSdr() bOk = False print("SetupSDR:{}: fC[{}] fS[{}] gain[{}]".format(bOk, fC, fS, gain)) return sdr, bOk
def __init__(self, dev_index=None, freq_range=None, freq_count=None, sample_rate=None, gain=None): eget = os.environ.get if dev_index is None: dev_index = int(eget('RANDIO_DEV_INDEX', 0)) if freq_range is None: low = int(eget('RANDIO_FREQ_LOW', 64)) * MHZ high = int(eget('RANDIO_FREQ_HIGH', 1100)) * MHZ freq_range = (low, high, 1000) if freq_count is None: freq_count = int(eget('RANDIO_FREQ_COUNT', 32)) if sample_rate is None: sample_rate = float(eget('RANDIO_SAMPLE_RATE', 1.2)) * MHZ if gain is None and 'RANDIO_GAIN' in os.environ: gain = int(eget('RANDIO_GAIN')) else: gain = 'auto' self.pool_size = freq_count * SHA_SIZE self.pool = bytearray(" " * self.pool_size) self.poolblocks = range(0, self.pool_size, SHA_SIZE) self.radio = rtlsdr.RtlSdr(dev_index) self.radio.rs = sample_rate self.radio.gain = gain self.freq_range = freq_range self.freq_count = freq_count self.sample() super(Randio, self).__init__()
def run(self): self.logger.info("Tuner start reading") if self.filename is None: # DEFAULT_ASYNC_BUF_NUMBER is the number of elements in the ring buffer within librtlsdr c-implementation # pyrtlsdr sets this to 15. This means that the callback function (signal) is called # MODES_ASYNC_BUF_NUMBER (16) times before it starts to overwriting the first buffer in the ring # The read_samples_async is a blocking function from where the callback function is called, # cancel_read_async needs to be called to return from read_samples_async. try: # self.sdr.read_samples_async(self._sdr_cb, num_samples=self.MODES_DATA_LEN) self.sdr_async_ts = time.time() self.sdr.read_bytes_async(self._sdr_cb, num_bytes=self.MODES_DATA_LEN) except IOError as msg: err_str = "Tuner caught rtlsdr error reading async {}".format( msg) self.logger.error(err_str) self.email.send(basic.ADSB.cfg_email_recipient, "Spots error", err_str) if time.time() - self.sdr_async_ts >= 1.0: self.sdr = rtlsdr.RtlSdr() self.sdr.gain = max(self.sdr.get_gains( )) if self.original_gain == 'max' else self.original_gain self.sdr.set_agc_mode(0) self.logger.info("Tuner re-initialised to gain {}".format( self.sdr.gain)) self.run() else: # It was less than 1 sec than we tried to create a new instance of sdr, give it up self.logger.info( "Tuner no luck to re-initialised...time to die") self.die() else: self._sdr_cb(self.sig, None)
def GetSample(f_station, f_offset, fs, N, gain='auto'): """ Genera una muestra de radio FM: Parametros: f_station: Frecuencia de la Estación f_offset: Frecuencia corrida fs: Frecuencia de muestreo N: Cantidad de muestras gain: Ganancia de la señal """ sdr = rtlsdr.RtlSdr() fc = f_station - f_offset # Frecuencia del centro de captura # Se configura los parametros sdr.sample_rate = fs sdr.center_freq = fc sdr.gain = gain # Lee las N muestras samples = sdr.read_samples(N) # Limpiar el dispositivo SDR sdr.close() del (sdr) return samples
def __init__(self, hittite_addr='192.168.1.70'): self.hittite = hittiteController(addr=hittite_addr) self.rtl = rtlsdr.RtlSdr() self.rtl.sample_rate = 256e3 self.rtl.gain = 30.0
if d['prgMode'] == PRGMODE_SCAN: scan_range(d) elif d['prgMode'] == PRGMODE_ZEROSPANSAVE: zero_span_save(d) elif d['prgMode'] == PRGMODE_ZEROSPANPLAY: zero_span_play_setup(d) zero_span(d) d['zeroSpanFile'].close() else: zero_span(d) gD = {} gD['cmd.stop'] = False handle_args(gD) _load_siglvls(gD) print_info(gD) handle_signals(gD) plt_figures(gD) gD['sdr'] = rtlsdr.RtlSdr() sdr_info(gD['sdr']) do_run(gD) gD['sdr'].close() _save_siglvls(gD) gD['BtnQuit'].label.set_text("QuitPress") input("Press any key to quit...")
""" import rtlsdr from pylab import * import matplotlib.pyplot as plt import numpy as np import scipy.signal as signal from scipy.io.wavfile import write fs = 1e6 # sampling frequency f_int = 100.4e6 f_off = 240000 #offset to account for dc spike fc = f_int - f_off N = 4194304 gain = 25.6 sdr = rtlsdr.RtlSdr() sdr.sample_rate = fs sdr.center_freq = fc sdr.gain = 30.7 x = sdr.read_samples(N) sample = np.array(x).astype("complex64") # power spectral diagram with shift plt.psd(sample, NFFT=1024, Fs=sdr.sample_rate / 1e6, Fc=sdr.center_freq / 1e6) plt.xlabel('Frequency (MHz)') plt.ylabel('Relative power (dB))') plt.savefig("psd diagram.pdf", bbox_inches='tight', pad_inches=0.5) plt.close()
def do_enableSDR(self, args): """Enables the RTLSDR so that I/Q Data can be sampled from it""" try: self.sdr = rtlsdr.RtlSdr() except: print "Error enabling SDR make sure it is plugged in and using the libusb driver"
def __init__(self, fc, fs, bw, gain): self.sdr = rtl.RtlSdr() sleep(1) self.setGain(gain) self.setFc(fc, "mhz") self.setFs(fs, "mhz")
def rtlsdr_init(): sdr = rtlsdr.RtlSdr() print(dir(sdr)) print("GainValues/*DivBy10AndThenUse*/:{}".format(sdr.gain_values)) return sdr