def storing_stream_with_windows(l, device_number, folder, subfolders, center_frequency, samplerate, gain, nsamples, freq_correction,
user_hash):
l.acquire()
print(device_number, center_frequency, samplerate, gain, nsamples, freq_correction)
# configure device
sdr = RtlSdr(device_index=device_number)
sdr.center_freq = center_frequency
sdr.sample_rate = samplerate
if freq_correction:
sdr.freq_correction = freq_correction # PPM
sdr.gain = gain
print('hello world')
timestamp = time.mktime(time.gmtime())
samples = sdr.read_bytes(nsamples*2)
sdr.close()
l.release()
print("save")
basename = "{hash}_{freq}_{time:0.0f}".format(hash=user_hash, freq=center_frequency, time=timestamp)
filename = path.join(folder, subfolders[0], "tmp_" + basename)
# np.savez_compressed(filename, samples) # storing by numpy and copressing it
'''np.save(filename, samples)
os.rename(filename + ".npy",
path.join(folder, subfolders[0], basename + ".npy"))'''
f = open(filename, 'wb')
f.write(samples)
f.close()
os.rename(filename,
path.join(folder, subfolders[0], basename + ".dat"))
del samples
filename = path.join(folder, subfolders[1], basename + ".npy")
sdrmeta(filename, device_number, folder, subfolders, center_frequency,
samplerate, gain, nsamples, freq_correction, user_hash)
return filename
def storing_stream_with_windows(lock, rs, cf, gain, ns, device, path_storing):
if 0==0:#librtlsdr.rtlsdr_get_device_count() > 0:
lock.acquire(timeout=ns/rs*1.1)
print("locked")
sdr = RtlSdr(device_index = device)
# some defaults
sdr.rs = rs
sdr.fc = cf
sdr.gain = gain
timestamp = time.time()
samples = sdr.read_bytes(ns * 2)
sdr.close()
lock.release()
#print("print")
filename = get_groundstationid() + "_f" + str(cf) + "_d" + str(device) + "_t" + str(int(timestamp))
f = open(path_storing + filename + ".tmp", 'wb')
f.write(samples)
f.close()
os.rename(path_storing + filename + ".tmp", path_storing + filename + ".dat")
for sat_name in active_orbcomm_satellites:
sat = active_orbcomm_satellites[sat_name]['sat_obj']
sat.compute(obs)
if degrees(sat.alt) > min_elevation:
sats.append(sat_name)
tles.append(active_orbcomm_satellites[sat_name]['tles'])
if len(sats) > 0:
print("\nSatellites overhead: ")
for sat_name in sats:
sat = active_orbcomm_satellites[sat_name]['sat_obj']
sat.compute(obs)
print('{:20}: {:3.1f} degrees elevation'.format(
sat_name, degrees(sat.alt)))
record_time = time()
samples = sdr.read_bytes(num_samples_per_recording * 2)
complex_samples = np.frombuffer(samples, dtype=np.uint8)
complex_samples = complex_samples.astype(np.float32) - 128
complex_samples = complex_samples.astype(np.float32).view(
np.complex64)
filename = '{:.3f}'.format(record_time).replace('.', 'p') + '.mat'
save_dict = {
'samples': complex_samples,
'timestamp': record_time,
'sats': sats,
'tles': tles,
'fs': sample_rate,
'fc': center_freq,
'lat': lat,
'lon': lon,
'alt': alt,
sdr.sample_rate = Fs # Hz
sdr.center_freq = Fc # Hz
sdr.gain = 'auto'
# An FM broadcast signal has a bandwidth of 200 kHz
f_bw = 200000
n_taps = 64
# Use Remez algorithm to design filter coefficients used for downscaling in frequency.
lpf = signal.remez(n_taps, [0, f_bw, f_bw + (Fs / 2 - f_bw) / 4, Fs / 2],
[1, 0],
Hz=Fs)
# Read samples
before = time.time()
samples = sdr.read_bytes(2 * N)
print time.time() - before
# Convert samples to a numpy array
x1 = sdr.packed_bytes_to_iq(samples)
# To mix the data down, generate a digital complex exponential
# (with the same length as x1) with phase -F_offset/Fs
fc1 = np.exp(-1.0j * 2.0 * np.pi * F_offset / Fs * np.arange(len(x1)))
# Now, just multiply x1 and the digital complex exponential
x2 = x1 * fc1
# Downsample the signal
x3 = signal.lfilter(lpf, 1.0, x2)
