def initServer(self):
self.dac = self.client.servers['laserdac_server']
# first plug in slave dongle and then plug in supervisor dongle!!!!!!!!!!!
sdr1 = RtlSdr(device_index=0)
sdr2 = RtlSdr(device_index=1)
self.supervisormodel = model.FreqShowModel(config.first, config.second, sdr1)
self.slavemodel = model.FreqShowModel(config.first, config.second, sdr2)
self.thread_supervisor = KThread(target=self.supervisor)
self.thread_slave = KThread(target=self.slave)
def __init__(self, freq=0, rate=1200000, offset=250000):
self.sdr = RtlSdr()
self.freq = freq
self.rate = rate
self.offset = offset
self.sdr.gain = 'auto'
self.sdr.sample_rate = self.rate
def read_frequency(fq):
sdr = RtlSdr()
# Set parameters
sampling_rate = 2400000
center_freq = fq * 1.000e6
# print(sdr.valid_gains_db)
gain = 40.2
sdr.set_sample_rate(sampling_rate)
sdr.set_center_freq(center_freq)
sdr.set_gain(gain)
time_duration = 1 # if noisy plot try longer duration
N_Samples = sampling_rate * time_duration
y = sdr.read_samples(N_Samples) # comment out after collecting data
# y = np.load(str(int(center_freq)) + ".npy") # uncomment after collecting data
sdr.close()
interval = 2048
chunks = N_Samples // interval
N = interval * chunks
y = y[:N]
# np.save(str(int(center_freq)), y) # comment out after collecting data
# Calculate average power spectrum
y = y[:len(y // interval * interval)]
y = y.reshape(N // interval, interval)
y_windowed = y * np.kaiser(interval, 6)
Y = fftshift(fft(y_windowed, axis=1), axes=1)
Pspect = mean(abs(Y) * abs(Y), axis=0)
return Pspect
async def streaming():
sdr = RtlSdr()
sdr.sample_rate = 1.2e6
sdr.center_freq = 91.8e6
prev = None
device.write(np.array([0] * 100000).astype('int16'))
async for samples in sdr.stream():
samples = np.array(samples).astype('complex64')
samples = signal.decimate(samples, int(1.2e6 / 200e3))
if prev is not None:
samples = np.insert(samples, 0, prev)
prev = samples[-1]
samples = np.angle(samples[1:] * np.conj(samples[:-1]))
x = np.exp(-1 / (200e3 * 75e-6))
samples = signal.lfilter([1 - x], [1, -x], samples)
samples = signal.decimate(samples, int(200e3 / 50e3))
samples *= 10000
device.write(samples.astype('int16'))
await sdr.stop()
sdr.close()
async def streaming():
sdr = RtlSdr()
# configure device
Fs = 2.4e6 # Hz
sdr.sample_rate = Fs # Hz
sdr.center_freq = 98e6 # Hz
sdr.freq_correction = 60 # PPM
sdr.gain = 'auto'
# Sampling for 1 sec
t_sampling = 1
N_samples = round(Fs * t_sampling)
samples = sdr.read_samples(N_samples)
fig = plt.figure(1)
plt.xlabel('Frequency (MHz)')
plt.ylabel('Relative power (dB)')
fig.show()
async for samples in sdr.stream():
plt.psd(samples,
NFFT=1024,
Fs=sdr.sample_rate / 1e6,
Fc=sdr.center_freq / 1e6)
plt.title("Dynamic Plot")
plt.draw()
plt.pause(0.1)
fig.clear()
# to stop streaming:
await sdr.stop()
# done
sdr.close()
def __loadDevice(self):
# self.radio = RtlSdr()
try:
self.radio = RtlSdr()
return True
except:
return False
def run(self):
#Import here so that a working RtlSdr isn't required to work with recordings
from rtlsdr import RtlSdr, RtlSdrTcpClient
self.sdr = RtlSdr()
#self.sdr = RtlSdrTcpClient(hostname='192.168.0.6', port=1234)
# configure device
self.sdr.center_freq = self.center_freq
self.sdr.sample_rate = self.sample_rate
self.sdr.gain = self.gain
if self.freq_correction != 0:
self.sdr.freq_correction = self.freq_correction
#try for some extra filtering
try:
#self.sdr.bandwidth = (.350 * 1e6)
pass
except IOError:
print("No bandwidth adjustment availible.")
print("SDR Frequency: {}MHz".format(self.sdr.get_center_freq() / 1e6))
print("SDR Sample Rate: {}MS/s".format(self.sdr.get_sample_rate() /
1e6))
self.sdr.read_samples_async(self.send_samples, self.async_sample_size)
print("Radio closing...")
def main():
sdr = RtlSdr()
print 'Configuring SDR...'
sdr.rs = 2.4e6
sdr.fc = 100e6
sdr.gain = 10
print ' sample rate: %0.6f MHz' % (sdr.rs / 1e6)
print ' center frequency %0.6f MHz' % (sdr.fc / 1e6)
print ' gain: %d dB' % sdr.gain
print 'Reading samples...'
samples = sdr.read_samples(256 * 1024)
print ' signal mean:', sum(samples) / len(samples)
print 'Testing callback...'
sdr.read_samples_async(test_callback, 256 * 1024)
try:
import pylab as mpl
print 'Testing spectrum plotting...'
mpl.figure()
mpl.psd(samples, NFFT=1024, Fc=sdr.fc / 1e6, Fs=sdr.rs / 1e6)
mpl.show()
except:
# matplotlib not installed/working
pass
print 'Done\n'
sdr.close()
def connect(self, device_index: int = 0):
try:
self._sdr = RtlSdr(device_index=device_index)
self._connected = True
except:
self._sdr = None
self._connected = False
def __init__(self, sdr=None, fig=None):
self.fig = fig if fig else pyl.figure()
self.sdr = sdr if sdr else RtlSdr()
self.init_plot()
def get_muestras(n_samples): sdr = RtlSdr() sdr.sample_rate = Fs sdr.center_freq = Fo sdr.freq_correction = 60 sdr.gain = 'auto' return sdr.read_samples(n_samples)
def configure_sdr(frequency, offset, sample_rate):
sdr = RtlSdr()
center_frequency = frequency - offset
sdr.sample_rate = sample_rate
sdr.center_freq = center_frequency
sdr.gain = 'auto'
return sdr
def __init__(self, sampleRate, carrierFreq, demodulator):
self.sampleRate = sampleRate
self.carrierFreq = carrierFreq
self.rtl = RtlSdr()
self.rtl.sample_rate = self.sampleRate
self.rtl.center_freq = self.carrierFreq
self.demodulator = demodulator
async def main():
import math
sdr = RtlSdr()
print('Configuring SDR...')
sdr.rs = 2.4e6
sdr.fc = 100e6
sdr.gain = 10
print(' sample rate: %0.6f MHz' % (sdr.rs / 1e6))
print(' center frequency %0.6f MHz' % (sdr.fc / 1e6))
print(' gain: %d dB' % sdr.gain)
print('Streaming samples...')
i = 0
async for samples in sdr.stream():
power = sum(abs(s)**2 for s in samples) / len(samples)
print('Relative power:', 10 * math.log10(power), 'dB')
i += 1
if i > 100:
sdr.stop()
break
print('Done')
sdr.close()
def __main__(sdr=None, read_event=None, collect_event=None):
global Radio_Data
# Initialize SDR Component
if sdr == None:
sdr = RtlSdr()
sdr.set_bandwidth(.2e6) # Hz
sdr.sample_rate = 2.4e6
sdr.freq_correction = 60 # PPM
sdr.gain = 0.0
# Load initial data for all stations
start = time.time()
Collect_Data(sdr, read_event)
end = time.time()
print('All stations initialized in', end - start, 'seconds')
# Eliminate Dead Stations
# TODO: Re-enable call once it actually works
# Determine_Available_Stations()
# Clear event prior to its availability
if collect_event != None:
collect_event.clear()
# Infinite Runtime Loop
while True:
# TODO: Add interface for messages (remove station from search, terminate, ect)
if collect_event != None and collect_event.is_set():
Collect_Data(sdr, read_event)
collect_event.clear()
def _open_sdr_local(self):
serial_number = self.scanner.device_config.serial_number
try:
sdr = RtlSdr(serial_number=serial_number)
except IOError:
sdr = None
return sdr
def get_muestras(n_samples, sample_rate, center_freq):
sdr = RtlSdr()
sdr.sample_rate = sample_rate
sdr.center_freq = center_freq
sdr.freq_correction = 60
sdr.gain = 20
return sdr.read_samples(n_samples)
async def streaming():
size = 256
x_vec = np.linspace(0, 5, size + 1)[0:-1]
y_vec = np.random.randn(len(x_vec))
line1 = []
sdr = RtlSdr()
sdr.sample_rate = 2.048e6 # Hz
sdr.center_freq = 101e6 # Hz
sdr.freq_correction = 60 # PPM
sdr.gain = 4
i = 0
async for samples in sdr.stream(256):
i = i + 1
print("{i} sample")
print(samples)
for sample in samples:
rand_val = sample * 10000
y_vec[-1] = rand_val
line1 = live_plotter(x_vec, y_vec, line1)
y_vec = np.append(y_vec[1:], 0.0)
print(rand_val)
# to stop streaming:
await sdr.stop()
# done
sdr.close()
def check_rtl_device(device):
try:
sdr = RtlSdr(device_index = device)
sdr.close()
print("rtlsdr device", device, "ready")
except:
print("rtlsdr device", device, "not found")
def main():
### setting up sdr streaming
srate = 2400000 #sampling rate
samplesperbit = 1000000 / 38400 / (1000000 / srate)
sdr = RtlSdr()
# Just like in URH
sdr.freq_correction = 1
sdr.sample_rate = srate
sdr.center_freq = 100.000e6
sdr.gain = 'auto'
# Run check_samples in another thread to make sure we don't miss any samples
### setting up TCP server
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Bind the socket to the port
server_address = (ipAddress, portNum)
print('starting up on {} port {}'.format(*server_address))
sock.bind(server_address)
# Listen for incoming connections
sock.listen(1)
t1 = threading.Thread(target=server_run, args=(sock,q2))
t1.start()
# This is the main loop
loop = asyncio.get_event_loop()
loop.run_until_complete(get_samples(sdr, q1, q2))
def capture(fc=94.3e6,
fs=int(1e6),
gain='auto',
seconds_dwell=.4
#offset_dc=5e4
):
N = int(seconds_dwell * fs)
with closing(RtlSdr()) as sdr:
sdr.sample_rate = fs
sdr.center_freq = fc # + int(offset_dc)
sdr.gain = gain
t = datetime.now()
stamp = datetime.timestamp(t)
loop = asyncio.get_event_loop()
samples_buffer = loop.run_until_complete(stream(sdr, N))
iq_samples = np.hstack(np.array(list(
samples_buffer.queue)))[:N].astype("complex64")
#iq_samples = shift_mix(iq_samples, -offset_dc, fs)
#path = os.path.join(out_dir, f'{stamp}.png')
meta = dict(fs=fs,
fc=fc,
gain=gain,
seconds_dwell=seconds_dwell,
dt_start=stamp)
return iq_samples, meta
def collectSignal(freq, freq_file_path, mag_file_path):
# Define function for writing signal data into file
def write_data(data_points, magnitudeData, frequencyData, mag_file,
freq_file):
i = 0
mag_file.write('[')
freq_file.write('[')
while i < data_points - 1:
mag_file.write("%s, " % magnitudeData[i])
freq_file.write("%s, " % frequencyData[i])
i += 1
mag_file.write('%s]\n' % magnitudeData[i])
freq_file.write('%s]\n' % frequencyData[i])
sdr = RtlSdr()
# Configure SDR
sdr.sample_rate = 2.4e6 # Hz
sdr.center_freq = freq # Hz
sdr.freq_correction = 60 # PPM
sdr.gain = 4 # 'auto'
# Initialize
data_points = 1024
samples = sdr.read_samples(256 * data_points)
mag_file_path = mag_file_path + "magdata.txt"
freq_file_path = freq_file_path + "freqdata.txt"
### *** IMPORTANT *** (for later, when optimizing)
### I'm not sure if we should leave this outside of the function
### and move it to the end of the main code, after the flight path
### ends. Idk the impact of leaving the SDR open/on for an extended
### period of time. If we move sdr.close() outside, we have to
### remember to also move the above code outside as well.
### Leaving this line within this function should be fine for now.
sdr.close()
# PSD plot data
psddata = psd(samples,
NFFT=data_points,
Fs=sdr.sample_rate / 1e6,
Fc=sdr.center_freq / 1e6)
# Extracting pertinent information from the PSD plot calculation
magnitudeData = psddata[0]
frequencyData = psddata[1]
# Check for .txt file and write data
# Magnitude has not been converted to dB yet. To convert, 10*log(magnitude). This comment is for Ron.
if Path(mag_file_path).is_file() and Path(freq_file_path).is_file():
with open(mag_file_path, 'a') as mag_file, open(freq_file_path,
'a') as freq_file:
write_data(data_points, magnitudeData, frequencyData, mag_file,
freq_file)
else:
with open(mag_file_path, 'w') as mag_file, open(freq_file_path,
'w') as freq_file:
write_data(data_points, magnitudeData, frequencyData, mag_file,
freq_file)
def get_info_from_device_index(self, device_index):
self.device_index = device_index
if self.device_serial is None:
self.device_serial = RtlSdr.get_device_serial_addresses(
)[device_index]
sdr = RtlSdr(device_index)
self._get_info_from_device(sdr)
sdr.close()
def get_info_from_device_serial(self, device_serial):
self.device_serial = device_serial
if self.device_index is None:
self.device_index = RtlSdr.get_device_index_by_serial(
device_serial)
sdr = RtlSdr(device_serial=device_serial)
self._get_info_from_device(sdr)
sdr.close()
def __init__(self):
self.sdr = RtlSdr()
# Sampling rate
self.sdr.rs = Demod.SAMP_RATE
# Pins 1 and 2
self.sdr.set_direct_sampling(1)
# I don't think this is used?
self.sdr.gain = 1
def capture_samples(self):
sdr = RtlSdr()
sdr.sample_rate = self.sample_rate
sdr.center_freq = self.freq - self.dc_offset
sdr.gain = 'auto'
self.samples = sdr.read_samples(self.sample_count)
self.samples_to_np()
sdr.close()
def sdr_init(index, freq, gain, sample_rate=2.4e6):
sdr = RtlSdr(device_index=index)
sdr.sample_rate = 2.4e6
sdr.center_freq = freq * 1e6
sdr.gain = gain
sdr.set_agc_mode(0)
sdr_get_power(sdr) #First read doesn't work
return sdr
def main():
sdr = RtlSdr()
# some defaults
sdr.rs = 2.4e6
sdr.fc = 146e6
sdr.gain = 50
noiseWindowLength = 20
noiseWindow = []
rampWindowLength = 5
rampWindow = []
rampPercent = 1.2
backgroundNoise = False
pulseFound = False
results = []
# Loop enough times to collect 3 seconds of data
sampleLoops = int(sdr.rs * 3 / 1024)
for i in range(0, sampleLoops):
samples = sdr.read_samples(1024)
curMag, freqs = magnitude_spectrum(samples, Fs=sdr.rs)
maxSignal = max(curMag)
noiseWindow.append(maxSignal)
if len(noiseWindow) > noiseWindowLength:
noiseWindow.pop(0)
backgroundNoise = sum(noiseWindow) / noiseWindowLength
rampWindow.append(backgroundNoise)
if len(rampWindow) > rampWindowLength:
rampWindow.pop(0)
if rampWindow[rampWindowLength -
1] > rampWindow[0] * rampPercent:
pulseFound = True
else:
pulseFound = False
results.append([maxSignal, backgroundNoise, pulseFound])
sdr.close()
f = open("data.csv", "w")
for result in results:
f.write(str(result[0]))
f.write(",")
f.write(str(result[1]))
f.write(",")
f.write(str(result[2]))
f.write("\n")
f.close()
def loadDevice(self):
try:
self.radio = RtlSdr()
self.radio.sample_rate = self.sample_rate
self.radio.center_freq = self.center_freq
self.radio.freq_correction = self.freq_correction
self.radio.gain = self.gain
return True
except:
return False
def __init__(self, **kwargs):
super(RtlReader, self).__init__()
self.signal_buffer = [] # amplitude of the sample only
self.sdr = 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
