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
