Esempio n. 1
0
class Rtl_threading(threading.Thread):
	def __init__(self, addr, fc, fs, size, corr):
		'''Add one more augument, corr'''
		threading.Thread.__init__(self)
		self.sdr = RtlSdr(addr)
		# configure device
		self.sdr.sample_rate = fs;  # Hz
		self.sdr.center_freq = fc;     # Hz
		# self.freq_correction = corr;   # PPM
		if addr==1:
			self.sdr.gain = 32.8
		else: #0
			self.sdr.gain = 32.8
		# init param
		self.addr = addr;
		self.size = size
		self.counter = 0;

#0.0 0.9 1.4 2.7 3.7 7.7 8.7 12.5 14.4 15.7 16.6 19.7 20.7 22.9 25.4 28.0 29.7 32.8 33.8 36.4 37.2 38.6 40.2 42.1 43.4 43.9 44.5 48.0 49.6

	def run(self):
		# start lock to avoid reading the same data
		global event, output; #init the synchronization
		if event.isSet():
			event.clear()
			event.wait()
		else:
			event.set()
		output[self.addr] = self.sdr.read_samples(self.size);
	def close(self):
		self.sdr.close();
Esempio n. 2
0
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()
Esempio n. 3
0
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()
Esempio n. 4
0
def get_sdr():
	sdr = RtlSdr()

	#configure device
	#sdr.sample_rate = 2.048e6 	#Hz
	#sdr.center_freq = 70e6		#Hz
	#sdr.freq_correction = 60	# PPM
	#sdr.gain = 'auto'
	sdr.sample_rate = 200000
	sdr.center_freq = 907 * 1000 * 1000
	sdr.freq_correction = 60	# PPM
	sdr.gain = 'auto'

	return sdr
Esempio n. 5
0
class SDR:
    def __init__(self,freq):
        self.sample_rate = 1e6

        self.center_freq = freq
        self.gain = 36

        self.sdr =  RtlSdr()
        self.sdr.direct_sampling = 1
        self.sdr.sample_rate = self.sample_rate
        self.sdr.center_freq = self.center_freq
        self.sdr.gain = self.gain
    def __del__(self):
        self.sdr.close()
Esempio n. 6
0
class Rtl_threading(threading.Thread):
    def __init__(self, addr, fc, fs, size, times, corr):

        threading.Thread.__init__(self)
        self.sdr = RtlSdr(addr)

        # configure device
        self.sdr.sample_rate = fs
        # Hz
        self.sdr.center_freq = fc
        # Hz
        # self.freq_correction = corr;   # PPM
        self.gain_index = 21

        # self.sdr.gain='auto'
        # 36.4 the stdev=0.04
        # init param
        self.addr = addr
        self.size = size
        self.times = times
        self.counter = 0
        self.output = np.array(maxn * [0.0], dtype=np.float64)
        self.keep = True

    def run(self):
        # start lock to avoid reading the same data
        # self.tlock.acquire()

        while self.keep:
            self.sdr.gain = gain_list[self.gain_index]
            output = self.sdr.read_samples(self.size)
            self.output = output
            time.sleep(0.05)
Esempio n. 7
0
    def __init__(self,freq,N_samples):

        self.sample_rate = 1e6
        self.decim_r1 = 1e6/2e5 # for wideband fm
        self.decim_r2 = 2e5/44100 # for baseband recovery
        self.center_freq = freq+250e3
        self.gain = 36

        self.N_samples = N_samples

        self.sdr =  RtlSdr()
        self.sdr.direct_sampling = 1
        self.sdr.sample_rate = self.sample_rate
        self.sdr.center_freq = self.center_freq
        self.sdr.gain = 'auto' #self.gain

        self.pa = pyaudio.PyAudio()
        self.stream = self.pa.open( format = pyaudio.paFloat32,
                                    channels = 2,
                                    rate = 44100,
                                    output = True)

        adj = 0
        hamming = 10*signal.hamming(self.N_samples*.10 + adj)
        lpf = np.append( np.zeros(self.N_samples*.45),hamming)
        self.lpf = np.roll(np.fft.fftshift(np.append(lpf,np.zeros(self.N_samples*.45))),int(-.25*self.N_samples))
Esempio n. 8
0
def transmit_and_capture(data, outfile, length, title='Captured Data', verbose=False, fs_audio=48000, fs_sdr=240000, fc0=443.650e6,  plot=False):
    """Transmit and receive a signal.
    length seconds
    """
    sdr = RtlSdr()          # Create an RtlSdr object
    p = pyaudio.PyAudio()   # Create a PyAudio object
    Nsamples=256000*length
    fc = fc0*(1.0-85e-6)

    # Get device numbers
    din, dout, dusb = audio_dev_numbers(p, in_name='USB', out_name='default', debug=verbose)

    # Create SDR capture thread as daemon
    capture = threading.Thread(target=sdr_record, args=(sdr, outfile, Nsamples, fc, fs_sdr))
    capture.daemon = True

    # Create play thread as daemon
    play = threading.Thread(target=play_audio, args=(data, p, fs_audio, dusb))
    play.daemon = True

    # Start both threads
    capture.start()
    play.start()

    time.sleep(length+2)

    try:
        if plot:
            print 'Loading data...'
            y = np.load(outfile)
            print 'Generating plot...'
            tt,ff,xmf = myspectrogram_hann_ovlp(y, 256, fs_sdr, fc)
            plt.title(title)
            plt.show()
        else:
            print 'Captured data saved to ' + outfile
    except IOError:
        type, value, traceback = sys.exc_info()
        print('Error loading %s: %s' % (value.filename, value.strerror))
    except Exception as e:
        print 'Error: '+str(e)
    finally:
        print 'Cleaning up...'
        sdr.close()
        p.terminate()
        print 'Closed SDR and PyAudio'
Esempio n. 9
0
 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
Esempio n. 10
0
    def __init__(self,freq,N_samples):

        QtGui.QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.createQtConnections()


        self.sample_rate = 2.4e5 ###1e6
        #self.decim_r1 = 1e6/2e5 # for wideband fm
        self.decim_r2 = 2.4e5/48000 # for baseband recovery
        self.center_freq = freq #+250e3
        self.gain = 38

        self.N_samples = N_samples
        self.is_sampling = False

        self.spectrogram = np.zeros((328,200))
        self.chspectrogram = np.zeros((328,200))
        self.plspectrogram = np.zeros((164,200))

        self.sdr =  RtlSdr()
        #self.sdr.direct_sampling = 1
        self.sdr.sample_rate = self.sample_rate
        self.sdr.center_freq = self.center_freq
        self.sdr.gain = self.gain

        self.pa = pyaudio.PyAudio()
        self.stream = self.pa.open( format = pyaudio.paFloat32,
                                    channels = 2,
                                    rate = 48000,
                                    output = True)

        adj = 0
        hamming = np.kaiser(self.N_samples/4 + adj,1)
        lpf = np.append( np.zeros(self.N_samples*3/8),hamming)
        self.lpf = np.fft.fftshift(np.append(lpf,np.zeros(self.N_samples*3/8))) #,int(-.25*self.N_samples))

        hamming = 10*signal.hamming(self.N_samples/16)
        lpf = np.append(np.zeros(self.N_samples*15/32),hamming)
        self.lpf_s1 = (np.append(lpf,np.zeros(int(self.N_samples*15/32))))
        #self.lpf_s1 = np.roll(temp,int(.5*self.N_samples*67/120))
        #self.lpf_s1 += np.roll(temp,int(-.5*self.N_samples*67/120))
        self.lpf_s1 = np.fft.fftshift(self.lpf_s1)
        #self.lpf_s1 += np.fft.fftshift(self.lpf_s1)

#         fig = plt.figure()
#         ax = fig.add_subplot(111)
#         ax.plot(range(self.lpf_s1.size),self.lpf_s1)
#         fig.show()

        hamming = 10*signal.hamming(self.N_samples/32)
        lpf = np.append(np.zeros(self.N_samples*31/64),hamming)
        self.lpf_s2 = (np.append(lpf,np.zeros(int(self.N_samples*31/64))))
        #self.lpf_s2 = np.roll(temp,int(.5*self.N_samples*92/120))
        #self.lpf_s2 += np.roll(temp,int(-.5*self.N_samples*92/120))
        self.lpf_s2 = np.fft.fftshift(self.lpf_s2)
Esempio n. 11
0
 def device_index(self):
     i = getattr(self, '_device_index', None)
     if i is None:
         serial_number = self.device_config.serial_number
         if serial_number is None:
             i = 0
         else:
             i = RtlSdr.get_device_index_by_serial(serial_number)
         self._device_index = i
     return i
Esempio n. 12
0
def main():
    sdr = RtlSdr()

    print 'Configuring SDR...'
    sdr.rs = 2.4e6
    sdr.fc = 70e6
    sdr.gain = 4
    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(1024)
    print '  signal mean:', sum(samples)/len(samples)

    print 'Testing callback...'
    sdr.read_samples_async(test_callback)

    sdr.close()
Esempio n. 13
0
def main():
    sdr = RtlSdr()
    wf = Waterfall(sdr)

    # some defaults
    # Sample rate
    sdr.rs = 1e6
    sdr.set_direct_sampling('q')

    sdr.fc = 0
    sdr.gain = 10

    wf.start()

    # cleanup
    sdr.close()
Esempio n. 14
0
class Rtl_threading(threading.Thread):
	def __init__(self, addr, fc, fs, size, times, corr):

		threading.Thread.__init__(self)
		self.sdr = RtlSdr(addr)
		# configure device
		self.sdr.sample_rate = fs;  # Hz
		self.sdr.center_freq = fc;     # Hz
		# self.freq_correction = corr;   # PPM
		if addr==1:

			self.sdr.gain = 32.8
			# 36.4 the stdev=0.04
		else: #0
			self.sdr.gain = 32.8

			#15.7 0.725
		# init param
		self.addr = addr;
		self.size = size
		self.times = times
		self.counter = 0;

#0.0 0.9 1.4 2.7 3.7 7.7 8.7 12.5 14.4 15.7 16.6 19.7 20.7 22.9 25.4 28.0 29.7 32.8 33.8 36.4 37.2 38.6 40.2 42.1 43.4 43.9 44.5 48.0 49.6

	def run(self):
		# start lock to avoid reading the same data
		# self.tlock.acquire()
		for x in range(0, self.times):
			timestamp = int(time.time());
			global event; #init the synchronization
			if event.isSet():

				event.clear()
				event.wait()
			else:
				event.set()
			#read
			time_str_read = int(time.time());
			output = self.sdr.read_samples(self.size);
			i=0
			for value in output:
				if self.addr == 0:
					rsamples[i] = value.real;
					isamples[i] = value.imag;
				else:
					rsamples1[i] = value.real;
					isamples1[i] = value.imag;
				i+=1;
Esempio n. 15
0
	def __init__(self, addr, fc, fs, size, corr):
		'''Add one more augument, corr'''
		threading.Thread.__init__(self)
		self.sdr = RtlSdr(addr)
		# configure device
		self.sdr.sample_rate = fs;  # Hz
		self.sdr.center_freq = fc;     # Hz
		# self.freq_correction = corr;   # PPM
		if addr==1:
			self.sdr.gain = 32.8
		else: #0
			self.sdr.gain = 32.8
		# init param
		self.addr = addr;
		self.size = size
		self.counter = 0;
Esempio n. 16
0
class Rtl_threading(threading.Thread):
    def __init__(self, addr):
        global params
        threading.Thread.__init__(self)
        self.sdr = RtlSdr(addr)
        # configure device
        self.sdr.sample_rate = params.fs
        # Hz
        self.sdr.center_freq = params.fc
        # Hz
        self.is_ref = addr == params.ref_addr
        # self.freq_correction = corr;   # PPM
        if self.is_ref:
            self.sdr.gain = params.ref_gain
        else:  # 0
            self.sdr.gain = params.ech_gain
            # init param
        self.addr = addr
        self.size = params.size
        # loop
        self.loop_sw = True

    def run(self):
        global event, wf_ech, wf_ref, dsp  # init the synchronization
        # start lock to avoid reading the same data
        if event.isSet():
            event.clear()
            event.wait()
        else:
            event.set()

        while self.loop_sw:
            # read
            print "reading new data~~~"
            output = self.sdr.read_samples(self.size)
            if self.is_ref:  # ref
                wf_ref = np.array(output, dtype=np.complex128)
            else:
                wf_ech = np.array(output, dtype=np.complex128)

            if event.isSet():
                event.clear()
                event.wait()
            else:
                dsp.new_data()
                event.set()
            self.loop_sw = False
Esempio n. 17
0
 def run(self):
   
   # Read 128ms of data at a time (must be a multiple of a power of two)
   blkSize = SAMPLE_RATE_KHZ()*128;
   blockLoc = np.zeros(1,dtype=np.uint64);
   
   sdr = RtlSdr();
   # configure device
   sdr.sample_rate = SAMPLE_RATE_KHZ()*1e3  # Hz
   sdr.center_freq = 1575420000     # Hz
   sdr.gain = 29;
   sdrQueue.put((sdr,blockLoc,blkSize/SAMPLE_RATE_KHZ(),1));
   sdr.read_samples_async(sdrCallback, blkSize, context=sdrQueue);
Esempio n. 18
0
def main():
    sdr = RtlSdr()
    wf = Waterfall(sdr)

    # some defaults
    sdr.rs = 2.4e6
    sdr.fc = 100e6
    sdr.gain = 10

    wf.start()

    # cleanup
    sdr.close()
Esempio n. 19
0
 def __init__(self, addr):
     global params
     threading.Thread.__init__(self)
     self.sdr = RtlSdr(addr)
     # configure device
     self.sdr.sample_rate = params.fs
     # Hz
     self.sdr.center_freq = params.fc
     # Hz
     self.is_ref = addr == params.ref_addr
     # self.freq_correction = corr;   # PPM
     if self.is_ref:
         self.sdr.gain = params.ref_gain
     else:  # 0
         self.sdr.gain = params.ech_gain
         # init param
     self.addr = addr
     self.size = params.size
     # loop
     self.loop_sw = True
Esempio n. 20
0
def main():
    from rtlsdr import RtlSdr

    sdr = RtlSdr()

    print 'Configuring SDR...'
    sdr.rs = 1e6
    sdr.fc = 70e6
    sdr.gain = 5
    print '   sample rate: %0.6f MHz' % (sdr.rs/1e6)
    print '   center ferquency %0.6f MHz' % (sdr.fc/1e6)
    print '   gain: %d dB' % sdr.gain

    print 'Testing callback...'
    sdr.read_samples_async(test_callback)
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
Esempio n. 22
0
	def __init__(self, addr, fc, fs, size, times, corr):

		threading.Thread.__init__(self)
		self.sdr = RtlSdr(addr)
		# configure device
		self.sdr.sample_rate = fs;  # Hz
		self.sdr.center_freq = fc;     # Hz
		# self.freq_correction = corr;   # PPM
		if addr==1:
			
			self.sdr.gain = 32.8
			# 36.4 the stdev=0.04
		else: #0
			self.sdr.gain = 32.8

			#15.7 0.725
		# init param
		self.addr = addr;
		self.size = size
		self.times = times
		self.counter = 0;
Esempio n. 23
0
    def __init__(self, addr, fc, fs, size, times, corr):

        threading.Thread.__init__(self)
        self.sdr = RtlSdr(addr)

        # configure device
        self.sdr.sample_rate = fs
        # Hz
        self.sdr.center_freq = fc
        # Hz
        # self.freq_correction = corr;   # PPM
        self.gain_index = 21

        # self.sdr.gain='auto'
        # 36.4 the stdev=0.04
        # init param
        self.addr = addr
        self.size = size
        self.times = times
        self.counter = 0
        self.output = np.array(maxn * [0.0], dtype=np.float64)
        self.keep = True
Esempio n. 24
0
def main():

    gin=sys.argv[1]
    ppm=sys.argv[2]
    chn=sys.argv[3]
    if ppm=='0': ppm='1'
    if chn=='a': frc=161.975e6
    if chn=='b': frc=162.025e6

    sdr = RtlSdr()
    wf = Waterfall(sdr)

    # some defaults
    sdr.rs = 1e6
    sdr.fc = frc
    sdr.gain = float(gin)
    sdr.freq_correction = int(float(ppm))

    wf.start()

    # cleanup
    sdr.close()
Esempio n. 25
0
    def __init__(self, gain, sampRate, freqs, numSamples, parent=None):
        super(Sampler, self).__init__(parent)
        self.gain = gain
        self.sampRate = sampRate
        self.freqs = freqs
        self.numSamples = numSamples
        self.offset = 0
        self.sdr = None
        self.errorMsg = None

        self.WORKING = True
        self.BREAK = False
        self.MEASURE = False

        try:
            self.sdr = RtlSdr()
            self.sdr.set_manual_gain_enabled(1)
            self.sdr.gain = self.gain
            self.sdr.sample_rate = self.sampRate
        except IOError:
            self.WORKING = False
            print "Failed to initiate device. Please reconnect."
            self.errorMsg = "Failed to initiate device. Please reconnect."
            self.samplerError.emit(self.errorMsg)
Esempio n. 26
0
def get_data(freq):
    sdr = RtlSdr()

    sdr.sample_rate = 2.048e6
    sdr.center_freq = int(decimal.Decimal(str(freq) + 'e6'))
    sdr.freq_correction = 60
    sdr.gain = 'auto'

    data = sdr.read_samples(512)

    if not data.any():
        app.abort(404, 'No data!')

    d = []
    for item in data:
        d.append(str(item))

    js = json.dumps(d)
    return js
Esempio n. 27
0
def main():

    @limit_time(0.01)
    @limit_calls(20)
    def read_callback(buffer, rtlsdr_obj):
        print('In callback')
        print('   signal mean:', sum(buffer)/len(buffer))

    from rtlsdr import RtlSdr

    sdr = RtlSdr()

    print('Configuring SDR...')
    sdr.rs = 1e6
    sdr.fc = 70e6
    sdr.gain = 5
    print('   sample rate: %0.6f MHz' % (sdr.rs/1e6))
    print('   center ferquency %0.6f MHz' % (sdr.fc/1e6))
    print('   gain: %d dB' % sdr.gain)

    print('Testing callback...')
    sdr.read_samples_async(read_callback)
def rt_flight_radar(fs, center_freq, gain, N_samples, pos_ref, functions):

    #clear_output()
    #time.sleep(1)
    # create an input output FIFO queues
    Qin = queue.Queue()

    # create a pyaudio object
    sdr = RtlSdr()
    sdr.sample_rate = fs  # sampling rate
    sdr.center_freq = center_freq  # 1090MhZ center frequency
    sdr.gain = gain

    # initialize map

    # Berkeley (lat, lon) = (37.871853, -122.258423)

    (mx_d, my_d) = LatLonToMeters(pos_ref[0] - 0.2, pos_ref[1] - 0.2)
    (mx_u, my_u) = LatLonToMeters(pos_ref[0] + 0.2, pos_ref[1] + 0.2)

    plot = figure(x_range=(mx_d, mx_u),
                  y_range=(my_d, my_u),
                  x_axis_type="mercator",
                  y_axis_type="mercator")
    plot.add_tile(get_provider('CARTODBPOSITRON'))

    plot.title.text = "Flight Radar"

    # create lat, longitude source
    source = ColumnDataSource(
        data=dict(lat=[], lon=[], heading=[], flightnum=[]))

    # create plane figure
    oval1 = Oval(x="lon",
                 y="lat",
                 width=3000,
                 height=700,
                 angle="heading",
                 fill_color="blue",
                 line_color="blue")
    oval2 = Oval(x="lon",
                 y="lat",
                 width=1000,
                 height=7000,
                 angle="heading",
                 fill_color="blue",
                 line_color="blue")
    text = Text(x="lon",
                y="lat",
                text_font_size="10pt",
                text="flightnum",
                angle="heading",
                text_color="red")

    plot.add_glyph(source, oval1)
    plot.add_glyph(source, oval2)
    plot.add_glyph(source, text)

    output_notebook()
    handle = show(plot, notebook_handle=True)

    # initialize write file
    log = open('rtadsb_log', 'a')

    # initialize stop_flag
    stop_flag = threading.Event()

    # initialize threads
    t_sdr_read = threading.Thread(target=sdr_read,
                                  args=(Qin, sdr, N_samples, stop_flag))
    t_signal_process = threading.Thread(target=signal_process,
                                        args=(Qin, source, functions, plot,
                                              log, stop_flag))

    # start threads
    t_sdr_read.start()
    t_signal_process.start()

    return stop_flag
Esempio n. 29
0
from rtlsdr import RtlSdr
import numpy as np
import scipy.signal as signal

import matplotlib
matplotlib.use('Agg') # necessary for headless mode
# see http://stackoverflow.com/a/3054314/3524528
import matplotlib.pyplot as plt


sdr = RtlSdr()

F_station = int(100.4e6)   #
F_offset = 250000         # Offset to capture at
# We capture at an offset to avoid DC spike
Fc = F_station - F_offset # Capture center frequency
Fs = int(1140000)         # Sample rate
N = int(8192000)            # Samples to capture

# configure device
sdr.sample_rate = Fs      # Hz
sdr.center_freq = Fc      # Hz
sdr.gain = 'auto'

# Read samples
samples = sdr.read_samples(N)

# Clean up the SDR device
sdr.close()
del(sdr)
Esempio n. 30
0
def run_spectrum_int(num_samp, nbins, gain, rate, fc, t_int):
    '''
    Inputs:
    num_samp: Number of elements to sample from the SDR IQ per call;
              use powers of 2
    nbins:    Number of frequency bins in the resulting power spectrum; powers
              of 2 are most efficient, and smaller numbers are faster on CPU.
    gain:     Requested SDR gain (dB)
    rate:     SDR sample rate, intrinsically tied to bandwidth in SDRs (Hz)
    fc:       Base center frequency (Hz)
    t_int:    Total effective integration time (s)

    Returns:
    freqs:       Frequencies of the resulting spectrum, centered at fc (Hz), 
                 numpy array
    p_avg_db_hz: Power spectral density (dB/Hz) numpy array
    '''
    # Force a choice of window to allow converting to PSD after averaging
    # power spectra
    WINDOW = 'hann'
    # Force a default nperseg for welch() because we need to get a window
    # of this size later. Use the scipy default 256, but enforce scipy
    # conditions on nbins vs. nperseg when nbins gets small.
    if nbins < 256:
        nperseg = nbins
    else:
        nperseg = 256

    print('Initializing rtl-sdr with pyrtlsdr:')
    sdr = RtlSdr()

    try:
        sdr.rs = rate  # Rate of Sampling (intrinsically tied to bandwidth with SDR dongles)
        sdr.fc = fc
        sdr.gain = gain
        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('  num samples per call: {}'.format(num_samp))
        print('  PSD binning: {} bins'.format(nbins))
        print('  requested integration time: {}s'.format(t_int))
        N = int(sdr.rs * t_int)
        num_loops = int(N / num_samp) + 1
        print('  => num samples to collect: {}'.format(N))
        print('  => est. num of calls: {}'.format(num_loops - 1))

        # Set up arrays to store power spectrum calculated from I-Q samples
        freqs = np.zeros(nbins)
        p_xx_tot = np.zeros(nbins)
        cnt = 0

        # Set the baseline time
        start_time = time.time()
        print('Integration began at {}'.format(
            time.strftime('%a, %d %b %Y %H:%M:%S',
                          time.localtime(start_time))))
        # Estimate the power spectrum by Bartlett's method.
        # Following https://en.wikipedia.org/wiki/Bartlett%27s_method:
        # Use scipy.signal.welch to compute one spectrum for each timeseries
        # of samples from a call to the SDR.
        # The scipy.signal.welch() method with noverlap=0 is equivalent to
        # Bartlett's method, which estimates the spectral content of a time-
        # series by splitting our num_samp array into K segments of length
        # nperseg and averaging the K periodograms.
        # The idea here is to average many calls to welch() across the
        # requested integration time; this means we can call welch() on each
        # set of samples from the SDR, accumulate the binned power estimates,
        # and average later by the number of spectra taken to reduce the
        # noise while still following Barlett's method, and without keeping
        # huge arrays of iq samples around in RAM.

        # Time integration loop
        for cnt in range(num_loops):
            iq = sdr.read_samples(num_samp)

            freqs, p_xx = welch(iq,
                                fs=rate,
                                nperseg=nperseg,
                                nfft=nbins,
                                noverlap=0,
                                scaling='spectrum',
                                window=WINDOW,
                                detrend=False,
                                return_onesided=False)
            p_xx_tot += p_xx

        end_time = time.time()
        print('Integration ended at {} after {} seconds.'.format(
            time.strftime('%a, %d %b %Y %H:%M:%S'), end_time - start_time))
        print('{} spectra were measured at {}.'.format(cnt, fc))
        print('for an effective integration time of {:.2f}s'.format(
            num_samp * cnt / rate))

        # Unfortunately, welch() with return_onesided=False does a sloppy job
        # of returning the arrays in what we'd consider the "right" order,
        # so we have to swap the first and last halves to avoid an artifact
        # in the plot.
        half_len = len(freqs) // 2

        freqs = np.fft.fftshift(freqs)
        p_xx_tot = np.fft.fftshift(p_xx_tot)

        # Compute the average power spectrum based on the number of spectra read
        p_avg = p_xx_tot / cnt

        # Convert to power spectral density
        # A great resource that helped me understand the difference:
        # https://community.sw.siemens.com/s/article/what-is-a-power-spectral-density-psd
        # We could just divide by the bandwidth, but welch() applies a
        # windowing correction to the spectrum, and does it differently to
        # power spectra and PSDs. We multiply by the power spectrum correction
        # factor to remove it and divide by the PSD correction to apply it
        # instead. Then divide by the bandwidth to get the power per unit
        # frequency.
        # See the scipy docs for _spectral_helper().
        win = get_window(WINDOW, nperseg)
        p_avg_hz = p_avg * ((win.sum()**2) / (win * win).sum()) / rate

        p_avg_db_hz = 10. * np.log10(p_avg_hz)

        # Shift frequency spectra back to the intended range
        freqs = freqs + fc

        # nice and tidy
        sdr.close()

    except OSError as err:
        print("OS error: {0}".format(err))
        raise (err)
    except:
        print('Unexpected error:', sys.exc_info()[0])
        raise
    finally:
        sdr.close()

    return freqs, p_avg_db_hz
Esempio n. 31
0
from matplotlib import pyplot as plt
from matplotlib import mlab as mlab
import matplotlib.animation as animation
from rtlsdr import RtlSdr

sdr = RtlSdr()
# configure device
sdr.sample_rate = 2.4e6  # Hz
sdr.center_freq = 94.7e6  # Hz
sdr.freq_correction = 60  # PPM
sdr.gain = 'auto'

fig = plt.figure()
graph_out = fig.add_subplot(1, 1, 1)


def animate(i):
    graph_out.clear()
    samples = sdr.read_samples(16 * 1024)
    power, psd_freq = mlab.psd(samples, NFFT=1024, Fs=sdr.sample_rate / 1e6)
    psd_freq = psd_freq + sdr.center_freq / 1e6
    graph_out.semilogy(psd_freq, power)


try:
    ani = animation.FuncAnimation(fig, animate, interval=10)
    plt.show()
except KeyboardInterrupt:
    pass
finally:
    sdr.close()
Esempio n. 32
0

import pyaudio
import wave
import time
import sys
import struct

from rtlsdr import RtlSdr
import matplotlib.pyplot as plt
import numpy as np

sdr = RtlSdr()

# configure device
sdr.sample_rate = 2.048e6  # Hz
sdr.center_freq = 102.5e6     # Hz 101.3 had osmething interesteing
sdr.freq_correction = 60   # PPM
sdr.gain = 'auto'


p = pyaudio.PyAudio()

def callback(in_data, frame_count, time_info, status):
    sample = np.fft.fft(sdr.read_samples(2048*4))
    #plt.plot( sample[1024*32:1024*32+256])
    val = struct.pack( 'h'  , np.argmax(np.abs(sample)) - 4150)
    print val
    return (val,pyaudio.paContinue)

Esempio n. 33
0
def run_fswitch_int(num_samp,
                    nbins,
                    gain,
                    rate,
                    fc,
                    fthrow,
                    t_int,
                    fswitch=10):
    '''
    Note: Because a significant time penalty is introduced for each retuning,
          a maximum frequency switching rate of 10 Hz is adopted to help 
          reduce the fraction of observation time spent retuning the SDR
          for a given effective integration time.
          As a consequence, the minimum integration time is 2*(1/fswitch)
          to ensure the user gets at least one spectrum taken on each
          frequency of interest.
    Inputs:
    num_samp: Number of elements to sample from the SDR IQ timeseries: powers of 2 are most efficient
    nbins:    Number of frequency bins in the resulting power spectrum; powers
              of 2 are most efficient, and smaller numbers are faster on CPU.
    gain:     Requested SDR gain (dB)
    rate:     SDR sample rate, intrinsically tied to bandwidth in SDRs (Hz)
    fc:       Base center frequency (Hz)
    fthrow:   Alternate frequency (Hz)
    t_int:    Total effective integration time (s)
    Kwargs:
    fswitch:  Frequency of switching between fc and fthrow (Hz)

    Returns:
    freqs_fold: Frequencies of the spectrum resulting from folding according to the folding method implemented in the f_throw_fold (post_process module)
    p_fold:     Folded frequency-switched power, centered at fc,(uncalibrated V^2) numpy array.
    '''
    from .post_process import f_throw_fold
    import rtlsdr.helpers as helpers

    # Check inputs:
    assert t_int >= 2.0 * (
        1.0 / fswitch
    ), '''At t_int={} s, frequency switching at fswitch={} Hz means the switching period is longer than integration time. Please choose a longer integration time or shorter switching frequency to ensure enough integration time to dwell on each frequency.'''.format(
        t_int, fswitch)

    if fswitch > 10:
        print(
            '''Warning: high frequency switching values mean more SDR retunings. A greater fraction of observation time will be spent retuning the SDR, resulting in longer wait times to reach the requested effective integration time.'''
        )

    print('Initializing rtl-sdr with pyrtlsdr:')
    sdr = RtlSdr()

    try:
        sdr.rs = rate  # Rate of Sampling (intrinsically tied to bandwidth with SDR dongles)
        sdr.fc = fc
        sdr.gain = gain
        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('  num samples per call: {}'.format(num_samp))
        print('  requested integration time: {}s'.format(t_int))

        # Total number of samples to collect
        N = int(sdr.rs * t_int)
        # Number of samples on each frequency dwell
        N_dwell = int(sdr.rs * (1.0 / fswitch))
        # Number of calls to SDR on each frequency
        num_loops = N_dwell // num_samp
        # Number of dwells on each frequency
        num_dwells = N // N_dwell
        print('  => num samples to collect: {}'.format(N))
        print('  => est. num of calls: {}'.format(N // num_samp))
        print('  => num samples on each dwell: {}'.format(N_dwell))
        print('  => est. num of calls on each dwell: {}'.format(num_loops))
        print('  => num dwells total: {}'.format(num_dwells))

        # Set up arrays to store power spectrum calculated from I-Q samples

        freqs_on = np.zeros(nbins)
        freqs_off = np.zeros(nbins)
        p_xx_on = np.zeros(nbins)
        p_xx_off = np.zeros(nbins)
        cnt = 0

        # Set the baseline time
        start_time = time.time()
        print('Integration began at {}'.format(
            time.strftime('%a, %d %b %Y %H:%M:%S',
                          time.localtime(start_time))))

        # Swap between the two specified frequencies, integrating signal.
        # Time integration loop
        for i in range(num_dwells):
            tick = (i % 2 == 0)
            if tick:
                sdr.fc = fc
            else:
                sdr.fc = fthrow
            for j in range(num_loops):
                iq = sdr.read_samples(num_samp)

                if tick:
                    freqs_on, p_xx = welch(iq,
                                           fs=rate,
                                           nperseg=nbins,
                                           noverlap=0,
                                           scaling='spectrum',
                                           detrend=False,
                                           return_onesided=False)
                    p_xx_on += p_xx
                else:
                    freqs_off, p_xx = welch(iq,
                                            fs=rate,
                                            nperseg=nbins,
                                            noverlap=0,
                                            scaling='spectrum',
                                            detrend=False,
                                            return_onesided=False)
                    p_xx_off += p_xx
                cnt += 1

        end_time = time.time()
        print('Integration ended at {} after {} seconds.'.format(
            time.strftime('%a, %d %b %Y %H:%M:%S'), end_time - start_time))
        print('{} spectra were measured, split between {} and {}.'.format(
            cnt, fc, fthrow))
        print('for an effective integration time of {:.2f}s'.format(
            num_samp * cnt / rate))

        half_len = len(freqs_on) // 2
        freqs_on = np.fft.fftshift(freqs_on)
        freqs_off = np.fft.fftshift(freqs_off)

        p_xx_on = np.fft.fftshift(p_xx_on)
        p_xx_off = np.fft.fftshift(p_xx_off)

        # Compute the average power spectrum based on the number of spectra read
        p_avg_on = p_xx_on / cnt
        p_avg_off = p_xx_off / cnt
        # Shift frequency spectra back to the intended range
        freqs_on = freqs_on + fc
        freqs_off = freqs_off + fthrow

        # Fold switched power spectra
        freqs_fold, p_fold = f_throw_fold(freqs_on, freqs_off, p_avg_on,
                                          p_avg_off)

        # nice and tidy
        sdr.close()

    except OSError as err:
        print("OS error: {0}".format(err))
        raise (err)
    except:
        print('Unexpected error:', sys.exc_info()[0])
        raise
    finally:
        sdr.close()

    return freqs_fold, p_fold
Esempio n. 34
0
from rtlsdr import RtlSdr
import numpy as np
import matplotlib.pyplot as plt
import timeit


sdr = RtlSdr()

# configure device
sdr.sample_rate = 2.3e5  # Hz
sdr.center_freq = 433e6  # Hz
sdr.freq_correction = 1  # PPM
sdr.gain = 80

N = 2 ** 18
M = 24
y = np.zeros(N * M, dtype=np.complex_)
print(N * M / sdr.sample_rate)


def listen(y):

    for i in range(M):
        idx = np.arange(N) + i * N
        x = np.array(sdr.read_samples(N))
        y[idx] = x
    return y


y = listen(y)
fig, ax = plt.subplots()
Esempio n. 35
0
from matplotlib.mlab import psd
import pylab as pyl
import numpy as np
from rtlsdr import RtlSdr

sdr = RtlSdr()

# configure device
sdr.sample_rate = 3.2e6
sdr.center_freq = 433e6

NFFT = 1024
NUM_ROWS = 1024
SKIP_ROWS = 8 # let AGC to settle
MIN_ROWS = 64
ZOOM_STEP = .9
SCROLL_STEP = .1
FREQ_ZOOM = 4
SAMPLES_PER_ROW = NFFT / FREQ_ZOOM


image_buffer = -100*np.ones((NUM_ROWS, SAMPLES_PER_ROW))
fig = pyl.figure()
ax = fig.add_subplot(1,1,1)
ax.set_xlabel('Current frequency (MHz)')
ax.set_ylabel('Time (sec)')
top_row = 0
num_row = NUM_ROWS

def read_buffer():
	samples = sdr.read_samples((SKIP_ROWS+NUM_ROWS)*NFFT)
Esempio n. 36
0
 def __init__(self):
     sdr = RtlSdr()
     CA = np.loadtxt('CA.txt', dtype=np.int16, unpack=True)
	def OnRefreshButton(self, event=0):
		from rtlsdr import RtlSdr
		serial_numbers = RtlSdr.get_device_serial_addresses()
		self.listApps.DeleteAllItems()
		for i in self.appsDict:
			item = self.listApps.InsertItem(0, i['name'])
			if i['name'] == 'AIS': 
				self.listApps.SetItem(item, 1, _('installed'))
				sdraisdeviceindex = self.conf.get('SDR-VHF', 'sdraisdeviceindex')
				if sdraisdeviceindex:
					self.listApps.SetItem(item, 2, sdraisdeviceindex)
					for ii in serial_numbers:
						if sdraisdeviceindex == str(RtlSdr.get_device_index_by_serial(ii)):
							self.listApps.SetItem(item, 3, ii)
				sdraisppm = self.conf.get('SDR-VHF', 'sdraisppm')
				if sdraisppm: self.listApps.SetItem(item, 4, sdraisppm)
			elif i['name'] == 'GQRX':
				if not os.path.isdir(self.conf.home+'/.config/gqrx'):
					self.listApps.SetItem(item, 1, _('not installed'))
					self.listApps.SetItemBackgroundColour(item,(200,200,200))
				else:
					self.listApps.SetItem(item, 1, _('installed'))
					try:
						device = ''
						gqrx_conf = configparser.ConfigParser()
						gqrx_conf.read(self.conf.home+'/.config/gqrx/default.conf')
						inputDevice = gqrx_conf.get('input', 'device')
						inputDevice = inputDevice.replace('"','')
						inputDevice = inputDevice.split('=')
						if inputDevice[0] == 'rtl': device = inputDevice[1]
						if device:
							self.listApps.SetItem(item, 2, device)
							for ii in serial_numbers:
								if device == str(RtlSdr.get_device_index_by_serial(ii)):
									self.listApps.SetItem(item, 3, ii)
						gqrxppm = gqrx_conf.get('input', 'corr_freq')
						if gqrxppm: self.listApps.SetItem(item, 4, str(int(gqrxppm)/1000000))
					except Exception as e: print('error getting gqrx settings: '+str(e))
			elif i['name'] == 'ADS-B':
				if not self.platform.isInstalled('piaware'):
					self.listApps.SetItem(item, 1, _('not installed'))
					self.listApps.SetItemBackgroundColour(item,(200,200,200))
				else:
					self.listApps.SetItem(item, 1, _('installed'))
					try:
						with open('/etc/default/dump1090-fa', 'r') as f:
							for line in f:
								if 'RECEIVER_OPTIONS=' in line:
									line = line.replace('\n', '')
									line = line.strip()
									items = line.split('=')
									item1 = items[1].replace('"', '')
									item1 = item1.strip()
									options = item1.split(' ')
									#--device-index 1 --gain -10 --ppm 0
									device = options[1]
									ppm = options[5]
									self.listApps.SetItem(item, 2, device)
									self.listApps.SetItem(item, 4, ppm)
									for ii in serial_numbers:
										if device == str(RtlSdr.get_device_index_by_serial(ii)):
											self.listApps.SetItem(item, 3, ii)
					except Exception as e: print(str(e))
			elif i['name'] == 'DAB':
				if not self.platform.isInstalled('welle.io'):
					self.listApps.SetItem(item, 1, _('not installed'))
					self.listApps.SetItemBackgroundColour(item,(200,200,200))
				else:
					self.listApps.SetItem(item, 1, _('installed'))
					self.listApps.SetItem(item, 2, _('First available'))
			elif i['name'] == 'DVB-T':
				if not self.platform.isInstalled('w-scan'):
					self.listApps.SetItem(item, 1, _('not installed'))
					self.listApps.SetItemBackgroundColour(item,(200,200,200))
				else:
					self.listApps.SetItem(item, 1, _('installed'))
					self.listApps.SetItem(item, 2, _('First available'))
		
		self.onListAppsDeselected()
		if self.started:
			self.started = False
			self.statusUpdate()
			self.started = True
		
		indexAis = self.listApps.GetItemText(0, 2)
		indexAdsb = self.listApps.GetItemText(1, 2)
		if indexAis == indexAdsb:
			try:
				subprocess.check_output(['systemctl', 'is-enabled', 'openplotter-rtl_ais']).decode(sys.stdin.encoding)
				worksAis = True
			except: worksAis = False
			try:
				subprocess.check_output(['systemctl', 'is-enabled', 'dump1090-fa']).decode(sys.stdin.encoding)
				worksAdsb = True
			except: worksAdsb = False
			if worksAis and worksAdsb:
				self.listApps.SetItemBackgroundColour(0,(255,0,0))
				self.listApps.SetItemBackgroundColour(1,(255,0,0))
Esempio n. 38
0
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# model.summary()

model.fit(Xtrain,
          Ytrain,
          epochs=50,
          batch_size=128,
          shuffle=True,
          validation_data=(Xtest, Ytest))

# ============================================== #

print("")
sdr = RtlSdr()
sdr.sample_rate = sample_rate = 2400000
sdr.err_ppm = 56
sdr.gain = 'auto'

correct_predictions = 0


def read_samples(freq):
    f_offset = 250000  # shifted tune to avoid DC
    sdr.center_freq = freq - f_offset
    time.sleep(0.06)
    iq_samples = sdr.read_samples(sample_rate * 0.25)  # sample 1/4 sec
    fc1 = np.exp(-1.0j * 2.0 * np.pi * f_offset / sample_rate *
                 np.arange(len(iq_samples)))  # shift down 250kHz
    iq_samples = iq_samples * fc1
Esempio n. 39
0
def main(input):

    print("let's find your SDR's oscillator precision")

    show_graph = input["graph"]
    verbose = input["verbose"]

    samplerate = input["rs"]
    mode = input["m"]

    if input["f"] is not None:
        print("loading file...")

        filename = input["f"]

        if os.path.exists(filename):
            data = cali.utils.load_data(filename, offset=44)

            if mode == "dab":
                print("starting mode: dab")
                ppm = cali.dabplus.dab.get_ppm(data, samplerate=samplerate, show_graph=show_graph, verbose=verbose)
                print("your sdr's precision is", ppm, "ppm")

            elif mode == "dvbt":
                print("starting mode: dvbt")
                cali.dvbt.dvbt.main()

            elif mode == "gsm":
                print("starting mode: gsm")
                cali.gsm.gsm.main()

            else:
                print("ending")

        else:
            print("sorry, file not found. try again.")


    elif input["s"] is not None:
        # scanning with your sdr

        print("scanning...")

        if mode == "dab":
            print("starting mode: dab")

            from rtlsdr import RtlSdr
            filename = "tmp.dat"
            device = input["rd"]
            sdr = RtlSdr(device_index=device)
            rs = input["rs"]
            rg = input["rg"]
            ns = rs * input["nsec"] #seconds
            c = input["c"]

            result = []

            dabchannels = cali.dabplus.dab.channels()

            if c == "all":
                print("Scanning all channels")

                for channel in tqdm(range(len(dabchannels["dab"])),
                                    desc="Scanning…",
                                    ascii=False,
                                    ncols=75):
                    channel, block, cf, dab_snr, dab_block_detected, dab_ppm = \
                        cali.utils.scan_one_dab_channel(dabchannels, channel, sdr, rs, ns, rg, filename, samplerate,
                                                        show_graph, verbose)

                    result.append([channel, block, cf, dab_snr, dab_block_detected, dab_ppm])

            else:
                print("Scanning only channel #", c)

                channel = int(c)
                channel, block, cf, dab_snr, dab_block_detected, dab_ppm = \
                    cali.utils.scan_one_dab_channel(dabchannels, channel, sdr, rs, ns, rg, filename, samplerate,
                                                    show_graph, verbose)

                result.append([channel, block, cf, dab_snr, dab_block_detected, dab_ppm])


            # output
            dab_snr_max = 0
            for i in range(len(result)):
                if i == 0 or dab_snr_max < result[i][3]:
                    dab_snr_max = result[i][3]


            print("")
            print("____Results_______________________________________________________________________________________")
            print("#   , block, freq [Hz], SNR [dB] , Prec. [ppm], offset [Hz], block [x][o][ ] & signal strength")
            print("--------------------------------------------------------------------------------------------------")
            for i in range(len(result)):
                channel = result[i][0]
                block = result[i][1]
                cf = result[i][2]
                dab_snr = result[i][3]

                dab_block_detected = "[ ]"
                if result[i][4] == 1:
                    dab_block_detected = "[o]"
                elif result[i][4] == 2:
                    dab_block_detected = "[x]"

                dab_ppm = result[i][5]

                bar = cali.utils.signal_bar(dab_snr, dab_snr_max)

                f_offset = 0.0

                if dab_ppm != None:
                    f_offset = cf / 1000000.0 * dab_ppm

                    print("# {0:2d}, {1:5s}, {2:9.0f}, {3:+9.5f}, {4:+10.4f}, {5:+11.1f}, {6:4s} {7}".
                          format(channel, block, cf, dab_snr, dab_ppm, f_offset, dab_block_detected, bar))
                else:

                    print("# {0:2d}, {1:5s}, {2:9.0f}, {3:+9.5f},       None, {5:+11.1f}, {6:4s} {7}".
                          format(channel, block, cf, dab_snr, dab_ppm, f_offset, dab_block_detected, bar))

            sdr.close()

        elif mode == "dvbt":
            print("starting mode: dvbt")
            cali.dvbt.dvbt.main()

        elif mode == "gsm":
            print("starting mode: gsm")
            cali.gsm.gsm.main()

        else:
            print("ending")
Esempio n. 40
0
    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()
Esempio n. 41
0
        distmin = 25
        distmax = 35
    elif (SNR < 37.455 and SNR > 30.5):
        distmin = 35
        distmax = 45
    elif (SNR < 30.5 and SNR > 25):
        distmin = 45
        distmax = 100
    return distmin, distmax


#print(len(sys.argv))
#print(sys.argv[0])

#configuring the device
sdr = RtlSdr(serial_number='0000103')
sdr.sample_rate = 1.024e6
sdr.bandwidth = 512e3
if len(sys.argv) == 2:
    sdr.center_freq = sys.argv[1]
else:
    sdr.center_freq = 462562500
print("Current Frequency: ", sdr.center_freq)
sdr.freq_correction = 1
sdr.gain = 6
#time = 21
snr_vals = []

#num_samples = int(sdr.sample_rate*time)
#print("Collecting ", num_samples, " samples")
Esempio n. 42
0
def saveSignal(freq, 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 = file_path + "/magdata.txt"
    freq_file_path = 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
    # For Ron: Magnitude has not been converted to dB yet. To convert, 10*log(magnitude).
    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)

    print("Data saved successfully.")
Esempio n. 43
0
pozadi_volba = raw_input("Odecist sumove pozadi :  a = ano // n = ne   :")
print("volba =", pozadi_volba)

if sirka_volba is 'a':
    pocet_vzorku = 8 * 512

if sirka_volba is 'b':
    pocet_vzorku = 32 * 512

if sirka_volba == 'c':
    pocet_vzorku = 128 * 512

if sirka_volba == 'd':
    pocet_vzorku = 1024 * 1024

sdr = RtlSdr()
pocet_oken = f_stop - f_start
f_start = f_start * 1e6
f_stop = f_stop * 1e6
sdr.sample_rate = 1.2e6  # Hz
sdr.freq_correction = +30  # korekce ochylky hodin, v PPM
sdr.gain = 12

sdr.center_freq = f_start + 0.5e6  # Hz
x = np.linspace(f_start, f_stop,
                pocet_oken * (int(round(pocet_vzorku * (1 / 1.2))))
                )  # definice velikosti pole pro vyslednou FFT - jen pro indexy

data = sdr.read_samples(
    pocet_vzorku)  # testovaci aktivace prijimace, prvni vzorky nejsou kvalitni
provede_mereni = 1

parser = argparse.ArgumentParser(
    formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--ppm', type=int, default=0, help='ppm error correction')
parser.add_argument('--gain', type=int, default=20, help='RF gain level')
parser.add_argument('--freq',
                    type=int,
                    default=92900000,
                    help='frequency to listen to, in Hertz')
parser.add_argument(
    '--lang',
    type=str,
    default='en-US',
    help='language to recognize, en-US, ru-RU, fi-FI or any other supported')
parser.add_argument('--buf',
                    type=int,
                    default=100,
                    help='buffer size to recognize, 100 = 6.25 seconds')
parser.add_argument('--verbose', action='store_true', help='mute audio output')

args = parser.parse_args()

sdr = RtlSdr()
sdr.rs = 1024000
sdr.fc = args.freq
sdr.gain = args.gain
sdr.err_ppm = args.ppm

sdr.read_samples_async(read_callback, int(sdr.get_sample_rate()) // 16)
        ps_real=sp.real
        ps_imag=sp.imag
        sq=np.power(ps_real,2)+np.power(ps_imag,2)
        sqrt=np.sqrt(sq)
        psd=sqrt/1024
        max=np.max(psd)
        log=10*math.log10(max)
        object.close()
        freq=object.get_center_freq()
        return log, freq


if __name__ == '__main__':
    
    # Find the device index for a given serial number
    sdr = RtlSdr(serial_number='00000001')
    sdr2 = RtlSdr(serial_number='00000002')
    
        
    #Set Center Frequency
    cntr_freq1=sdr.set_center_freq(88200000)
    cntr_freq2=sdr2.set_center_freq(103500000)
    
    #Set Gain
   
    sdr.gain = 15
    sdr2.gain = 15
    
    #Set sample rate
    sdr.rs = 2.4e6
    sdr2.rs = 2.4e6
Esempio n. 46
0
 def _open_sdr_local(self):
     try:
         sdr = RtlSdr()
     except IOError:
         sdr = None
     return sdr
Esempio n. 47
0
    sat = ephem.readtle(sat_line0, sat_line1, sat_line2)
    active_orbcomm_satellites[name]['sat_obj'] = sat
    active_orbcomm_satellites[name]['tles'] = [sat_line0, sat_line1, sat_line2]

# PyEphem observer
# set lat/long/alt in the CONFIG file
obs = ephem.Observer()
obs.lat, obs.lon = '{}'.format(lat), '{}'.format(lon)
obs.elevation = alt  # Technically is the altitude of observer

# Set RTLSDR parameters and initialize
sample_rate = 1.2288e6
center_freq = 137.5e6
gain = 'auto'  # Use AGC

sdr = RtlSdr()
sdr.rs = sample_rate
sdr.gain = gain
sdr.fc = center_freq

# Set recording parameters
record_length = 2.0  # seconds
record_interval = 5.0  # seconds

# receive samples that are an integer multiple of 1024 from the RTLSDR
num_samples_per_recording = int(
    (floor(record_length * sample_rate / 1024) + 1) * 1024)

file_count = 100
while 1:
    try:
Esempio n. 48
0
#!/usr/bin/python

from azure.servicebus import ServiceBusService
from rtlsdr import RtlSdr

sdr = RtlSdr()

# sdr
sdr.sample_rate = 2.048e6
sdr.center_freq = 70e6
sdr.freq_correction = 60
sdr.gain = 'auto'

# Azure
key_name = 'RootManageSharedAccessKey'
key_value = '6RS3yrdYH3Ds/+rQPKQjiG56VpzghffyCDNbxGTiivo='
service_namespace = 'hyperfineml'

x = 512
i = 0
samples = sdr.read_samples(x)

sbs = ServiceBusService(service_namespace,
                        shared_access_key_name=key_name,
                        shared_access_key_value=key_value)
if (sbs.create_event_hub('sdrhub')):
    while (i < x):
        sbs.send_event('sdr', '{"signalval": "' + str(samples[i]) + '"}')
        i = i + 1

    sbs.delete_event_hub('sdrhub')
Esempio n. 49
0
def run_total_power_int(num_samp, gain, rate, fc, t_int):
    '''
    Implement a total-power radiometer. Raw, uncalibrated power values.

    Inputs:
    num_samp:   Number of elements to sample from the SDR IQ timeseries per call
    gain:       Requested SDR gain (dB)
    rate:       SDR sample rate, intrinsically tied to bandwidth in SDRs (Hz)
    fc:         Bandpass center frequency (Hz)
    t_int:      Total integration time (s)

    Returns:
    p_tot:   Time-averaged power in the signal from the sdr, in 
             uncalibrated units
    '''
    import rtlsdr.helpers as helpers

    # Start the RtlSdr instance
    print('Initializing rtl-sdr with pyrtlsdr:')
    sdr = RtlSdr()

    try:
        sdr.rs = rate
        sdr.fc = fc
        sdr.gain = gain
        print('  sample rate: {} MHz'.format(sdr.rs / 1e6))
        print('  center frequency {} MHz'.format(sdr.fc / 1e6))
        print('  gain: {} dB'.format(sdr.gain))
        print('  num samples per call: {}'.format(num_samp))
        print('  requested integration time: {}s'.format(t_int))
        # For Nyquist sampling of the passband dv over an integration time
        # tau, we must collect N = 2 * dv * tau real samples.
        # https://www.cv.nrao.edu/~sransom/web/A1.html#S3
        # Because the SDR collects complex samples at a rate rs = dv, we can
        # Nyquist sample a signal of band-limited noise dv with only rs * tau
        # complex samples.
        # The phase content of IQ samples allows the bandlimited signal to be
        # Nyquist sampled at a data rate of rs = dv complex samples per second
        # rather than the 2* dv required of real samples.
        N = int(sdr.rs * t_int)
        print('  => num samples to collect: {}'.format(N))
        print('  => est. num of calls: {}'.format(int(N / num_samp)))

        global p_tot
        global cnt
        p_tot = 0.0
        cnt = 0

        # Set the baseline time
        start_time = time.time()
        print('Integration began at {}'.format(
            time.strftime('%a, %d %b %Y %H:%M:%S',
                          time.localtime(start_time))))

        # Time integration loop
        @helpers.limit_calls(N / num_samp)
        def p_tot_callback(iq, context):
            # The below is a total power measurement equivalent to summing
            # P = V^2 / R = (sqrt(I^2 + Q^2))^2 = (I^2 + Q^2)
            global p_tot
            p_tot += np.sum(np.real(iq * np.conj(iq)))
            global cnt
            cnt += 1

        sdr.read_samples_async(p_tot_callback, num_samples=num_samp)

        end_time = time.time()
        print('Integration ended at {} after {} seconds.'.format(
            time.strftime('%a, %d %b %Y %H:%M:%S'), end_time - start_time))
        print('{} calls were made to SDR.'.format(cnt))
        print('{} samples were measured at {} MHz'.format(
            cnt * num_samp, fc / 1e6))
        print('for an effective integration time of {:.2f}s'.format(
            (num_samp * cnt) / rate))

        # Compute the average power value based on the number of measurements
        # we actually did
        p_avg = p_tot / (num_samp * cnt)

        # nice and tidy
        sdr.close()

    except OSError as err:
        print("OS error: {0}".format(err))
        raise (err)
    except:
        print('Unexpected error:', sys.exc_info()[0])
        raise
    finally:
        sdr.close()

    return p_avg
mpl.use('TkAgg')

from tkinter import *

from numpy import *
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from rtlsdr import RtlSdr
import time
from SSN_modul.Received_power import received_power
from SSN_modul.Received_power import received_power2
from SSN_modul.self_psd import selfpsd

# Get a list of detected device serial numbers (str)
serial_numbers = RtlSdr.get_device_serial_addresses()

#---------------------------------------------------------first sensor
# Find the device index for a given serial number
device_index0 = RtlSdr.get_device_index_by_serial(serial_numbers[0])
sdr0 = RtlSdr(device_index0)
sdr0.sample_rate = 3.2e6
sdr0.center_freq = 1600 * 1e6
sdr0.gain = 4
#---------------------------------------------------------second sensor
device_index1 = RtlSdr.get_device_index_by_serial(serial_numbers[1])
sdr1 = RtlSdr(device_index1)
sdr1.sample_rate = 3.2e6
sdr1.center_freq = 1600 * 1e6
sdr1.gain = 4
N = 1
Esempio n. 51
0
class Demod:
  SAMP_RATE = 256000.
  SAMP_WINDOW = 1024*40

  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 run(self, limit=None, callback=lambda x: print(x),
                carrier=32000, bw=1000, sps=8, 
                codes=manchester, mod=Mods.MAGNITUDE, 
                header=HEADER, footer=FOOTER, pktlen=PKTBYTES):
    # Center frequency
    self.sdr.fc = carrier

    self.mod = mod
    self.header = header
    self.footer = footer
    self.pktlen = 8*pktlen + len(footer)

    self.rxcallback = callback

    decim = Demod.SAMP_RATE/bw/sps
    assert decim == int(decim)
    self.decim = int(decim)
    assert Demod.SAMP_WINDOW % self.decim == 0

    self.sampchips = Demod.SAMP_WINDOW / self.decim 
    self.corr = codes2corr(codes, sps)
    self.codelen = len(self.corr[0])

    self.last = np.zeros(Demod.SAMP_WINDOW)
    self.index = 0

    self.tocheck = [None] * self.codelen
    for i in range(self.codelen):
      self.tocheck[i] = dict()
      self.tocheck[i]['last'] = ''.join(range(0))
      self.tocheck[i]['pkts'] = range(0)

    if limit is None:
      def byte_callback(samp, sdr):
        if select.select([sys.stdin], [], [], 0)[0]:
          sdr.cancel_read_async()
        self.ddc(samp, sdr)
    else:
      @limit_calls(limit)
      def byte_callback(samp, sdr):
        if select.select([sys.stdin], [], [], 0)[0]:
          sdr.cancel_read_async()
        self.ddc(samp, sdr)

    self.sdr.read_bytes_async(byte_callback, Demod.SAMP_WINDOW*2)
    print (self.index, "samples read")
    sys.stdout.flush()
    sys.stdin.readline()

  def bb2c(self, baseband):
    mag = np.abs(baseband)
    phase = np.angle(baseband)
    dp = np.mod(np.ediff1d(phase)+np.pi, 2*np.pi)-np.pi
    return mag[1:], phase[1:], dp

  def decode(self, chips):
    corrs = []
    for c in self.corr:
      corrs.append(np.correlate(chips, c))
    # Vector correlations
    if np.iscomplex(corrs).any():
      corrs = np.abs(corrs)
    maxes = np.max(np.array(corrs), 0)
    codes = np.argmax(np.array(corrs), 0)
    return maxes, codes

  def debounce(self, i, l, rxstr):
    try:
      if i != self.debounce_i or abs(l - self.debounce_l) > 1:
        self.rxcallback(rxstr)
    except AttributeError:
      self.rxcallback(rxstr)
    self.debounce_i = i
    self.debounce_l = l

  def extract(self, nc):
    for codeoffset in range(self.codelen):
      pkts = []
      codestr = "".join(map(repr, map(int, nc[codeoffset::self.codelen])))

      for p in self.tocheck[codeoffset]['pkts']:
        pkt = p + codestr[0:self.pktlen-len(p)]
        if len(pkt) < self.pktlen:
          pkts.append(pkt)
        elif len(self.footer) == 0 or pkt[-len(self.footer):] == self.footer:
          str = ""
          for j in range(0,len(pkt)-1,8):
            str += chr(int(pkt[j:j+8][::-1], 2))
          self.debounce(self.index, -len(p), str)
          sys.stdout.flush()

      codestr = self.tocheck[codeoffset]['last'] + codestr
      for ind in find_all(codestr, self.header):
        pkt = codestr[ind+len(self.header):ind+len(self.header)+self.pktlen]
        if len(pkt) < self.pktlen:
          pkts.append(pkt)
        elif len(self.footer) == 0 or pkt[-len(self.footer):] == self.footer:
          str = ""
          for j in range(0,len(pkt)-1,8):
            str += chr(int(pkt[j:j+8][::-1], 2))
          self.debounce(self.index, ind, str)
          sys.stdout.flush()
      self.tocheck[codeoffset]['pkts'] = [] + pkts
      self.tocheck[codeoffset]['last'] = "" + codestr[-len(self.header)+1:]

  def ddc(self, samp, sdr):
    s = np.asarray(samp)
    i, q = s[::2], s[1::2]
    i = np.mean(i.reshape(-1,self.decim), 1) # poor man's decimation
    q = np.mean(q.reshape(-1,self.decim), 1) # poor man's decimation
    iq = np.empty(len(i), 'complex')
    iq.real, iq.imag = i, q
    iq /= (255/2)
    iq -= (1 + 1j)

    baseband = np.concatenate((self.last, iq))
    self.last = iq
    mag, phase, dp  = self.bb2c(baseband)
    if self.mod == Mods.MAGNITUDE:
      sig = mag
    elif self.mod == Mods.PHASE:
      sig = phase
    elif self.mod == Mods.DPHASE:
      sig = dp
    else:
      sig = baseband
    corrs, codes = self.decode(sig)

    nc = codes[self.codelen:self.codelen+self.sampchips]
    self.extract(nc)

    self.index += 1

  def end(self):
    self.sdr.close()

  def plot(self):
    plt.ion()
    fig = plt.figure()
    ax1 = fig.add_subplot(311)
    ax1.plot(self.chips)
    ax2 = fig.add_subplot(312, sharex=ax1)
    ax2.plot(self.corrs)
    ax3 = fig.add_subplot(313, sharex=ax1)
    ax3.plot(self.demod)
    plt.show()

  def checkdemod(self, index, demod=None, packetlen=5):
    if demod is None:
      demod = self.demod
    l = packetlen*8+6+7
    b = self.demod[index:index+l*self.codelen:self.codelen]
    return chipsToString(np.concatenate(([1,0], b, [0])))

  def findstring(self, demod = None, packetlen=5):
    if demod is None:
      demod = self.demod
    find = []
    for i in range(len(demod)):
      s, c = self.checkdemod(i, demod, packetlen)
      if len(s) and s[0] == 'a' and s[-1] == 'x':
        find.append((i, s[1:-1]))
    return find
Esempio n. 52
0
 def __loadDevice(self):
     try:
         self.radio = RtlSdr()
         return True
     except:
         return False
Esempio n. 53
0
class FMRadio:

     # num samplesmust be multiple of 256


    def __init__(self,freq,N_samples):

        self.sample_rate = 1e6
        self.decim_r1 = 1e6/2e5 # for wideband fm
        self.decim_r2 = 2e5/44100 # for baseband recovery
        self.center_freq = freq+250e3
        self.gain = 36

        self.N_samples = N_samples

        self.sdr =  RtlSdr()
        self.sdr.direct_sampling = 1
        self.sdr.sample_rate = self.sample_rate
        self.sdr.center_freq = self.center_freq
        self.sdr.gain = 'auto' #self.gain

        self.pa = pyaudio.PyAudio()
        self.stream = self.pa.open( format = pyaudio.paFloat32,
                                    channels = 2,
                                    rate = 44100,
                                    output = True)

        adj = 0
        hamming = 10*signal.hamming(self.N_samples*.10 + adj)
        lpf = np.append( np.zeros(self.N_samples*.45),hamming)
        self.lpf = np.roll(np.fft.fftshift(np.append(lpf,np.zeros(self.N_samples*.45))),int(-.25*self.N_samples))

    def __del__(self):
        print "sdr closed"
        self.sdr.close()
        print "pyaudio terminated"
        self.pa.terminate()

    def getSamples(self):
        #N_samples = self.N_samples # 1/24.4 seconds   ~46336 #approximately a blocksize amount's time
        return self.sdr.read_samples(self.N_samples)


#    def demodulate_threaded(self,samples):
#        async_demodulation = self.pool.apply_async(self.demodulate, samples, callback=self.play)


    def demodulate(self,samples):
        # DEMODULATION CODE
        #samples = #self.sample_buffer.get()
        # LIMITER goes here

        # low pass & down sampling via fft

        spectrum = np.fft.fft(samples)*self.lpf

        toplot = False
        if(toplot):
            fig = plt.figure()
            plt.plot(np.abs(spectrum))
            plt.show()

# Decimate in two rounds. One to 200k, another to 44.1k
        # DECIMATE HERE. Note that we're looking at 1MHz bandwidth.
        n_s = spectrum.size

        channel_spectrum = spectrum[int(n_s*.75-.5*n_s/self.decim_r1):int(.75*n_s+.5*n_s/self.decim_r1)] #np.append(spectrum[0:int(n_s/self.decim_r1*.5)],spectrum[n_s-int(n_s/self.decim_r1*.5):n_s])

        #radio_spectrum -= np.mean(radio_spectrum) #attempt to remove dc bias
        #print channel_spectrum.size
        toplot = False
        if(toplot):
            fig = plt.figure()
            plt.plot(np.abs(np.fft.ifftshift(channel_spectrum)))
            plt.show()


        lp_samples = np.fft.ifft(np.fft.ifftshift(channel_spectrum))


        power = np.abs(self.rms(lp_samples))
        lp_samples /= power
        #lp_samples = self.lowpass_filter(lp_samples,4)

    # polar discriminator

        A = lp_samples[1:lp_samples.size]
        B = lp_samples[0:lp_samples.size-1]

        dphase = ( A * np.conj(B) )

#dpm = np.mean(np.abs(dphase))
        # normalize
        #       dphase /= dpm
        dphase.resize(dphase.size+1)
        dphase[dphase.size-1] = dphase[dphase.size-2]

        rebuilt = signal.medfilt(np.angle(dphase)/np.pi,21) #  np.cos(dphase)

        #phase = np.sin(rebuilt)
        #phase = self.lowpass_filter(phase,8)

        #rebuilt= self.lowpass_filter(rebuilt,8)

        toplot = False
        if toplot:
            fig = plt.figure()
            ax = fig.add_subplot(111)
            ax.plot(rebuilt)

            plt.show()

        modulated = rebuilt * np.sin(2*np.pi*38000/2e5*np.r_[0:rebuilt.size])

        spectrum = np.fft.fft(rebuilt)
        mod_spectrum = np.fft.fft(modulated) #* self.lpf2



        n_z = spectrum.size
        #base_spectrum = np.append(spectrum[0:1024],spectrum[n_z-1024:n_z])
        base_spectrum = np.append(spectrum[0:int(n_z/self.decim_r2*.5)],spectrum[n_z-int(n_z/self.decim_r2*.5):n_s])
        stereo_spectrum = np.append(mod_spectrum[0:int(n_z/self.decim_r2*.5)],mod_spectrum[n_z-int(n_z/self.decim_r2*.5):n_s])
        stereo_spectrum *= np.fft.ifftshift(np.hamming(stereo_spectrum.size))

        toplot = False
        if(toplot):
            fig = plt.figure()
            plt.plot(np.linspace(-22050,22050,stereo_spectrum.size),np.abs(np.fft.fftshift(stereo_spectrum)),
                     np.linspace(-22050,22050,base_spectrum.size),.05*np.abs(np.fft.fftshift(base_spectrum)))
            plt.show()


        output = np.fft.ifft(base_spectrum)
        diff =np.fft.ifft(stereo_spectrum)
        #check: should be 1807 or very close to it. it is!!

        #output = self.lowpass_filter(np.real(output),8) #[12:8204]
        stereo = np.zeros(output.size*2,dtype='complex')
        left = output + 10*diff
        right = output - 10* diff
        stereo[0:stereo.size:2] = left
        stereo[1:stereo.size:2] = right
        #print 1e6/n_s / 44100 * output.size
        return np.real(stereo)


    def demodulate2(self,samples):
        # DEMODULATION CODE

        # LIMITER goes here

        # low pass & down sampling
        lp_samples = signal.decimate(self.lowpass_filter(samples,16),int(self.decim_r1))


    # polar discriminator

        A = lp_samples[1:lp_samples.size]
        B = lp_samples[0:lp_samples.size-1]

        dphase = ( A * np.conj(B) )

        dphase.resize(dphase.size+1)
        dphase[dphase.size-1] = dphase[dphase.size-2]

        rebuilt = signal.medfilt(np.angle(dphase)/np.pi,15) #  np.cos(dphase)

        output = signal.decimate(rebuilt,int(self.decim_r2))

        return np.real(output)

    def lowpass_filter(self,x,width):
        #wndw = np.sinc(np.r_[-15:16]/np.pi)/np.pi
        wndw = np.kaiser(width,6)
        wndw /= np.sum(wndw)
        new_array = signal.fftconvolve(x, wndw)

        return new_array[int(width/2):x.size+int(width/2)]

   # calculate rms for power #
    def rms(self,samples):
        meansq = np.mean(np.square(samples))
        return np.sqrt(meansq)

    def play(self,samples):
        self.stream.write( samples.astype(np.float32).tostring() )

    def start(self):
        while True:
            self.play(self.demodulate(self.getSamples()))
Esempio n. 54
0
from rtlsdr import RtlSdr
import dmrutils

reciever = RtlSdr()

reciever.sample_rate = 2.048e6  #hz
reciever.center_freq = 70e6  #hz
reciever.freq_correcetion = 60  #PPM
reciever.gain = 'auto'

print(reciever.read.samples(1024))
Esempio n. 55
0
class Rtl_threading(threading.Thread):
	def __init__(self, addr, fc, fs, size, times, corr):

		threading.Thread.__init__(self)
		self.sdr = RtlSdr(addr)
		# configure device
		self.sdr.sample_rate = fs;  # Hz
		self.sdr.center_freq = fc;     # Hz
		# self.freq_correction = corr;   # PPM
		if addr==1:

			self.sdr.gain = 15.7;
		else: #0
			self.sdr.gain = 32.8;

			#15.7 0.725
		# init param
		self.alive = True
		self.addr = addr;
		self.size = size
		self.times = times
		self.counter = 0;
		self.timestamp = int(time.time());

#0.0 0self.9 1.4 2.7 3.7 7.7 8.7 12.5 14.4 15.7 16.6 19.7 20.7 22.9 25.4 28.0 29.7 32.8 33.8 36.4 37.2 38.6 40.2 42.1 43.4 43.9 44.5 48.0 49.6

	def run(self):
		global event, samples0, samples1; #init the synchronization
		# start lock to avoid reading the same data
		if event.isSet():
			event.clear()
			event.wait()
		else:
			self.timestamp = int(time.time());
			event.set()

		for x in range(0, self.times):
			#read
			output = self.sdr.read_samples(self.size);

			if self.addr == 0:  #ref
				samples0 = np.array(output, dtype = np.complex128);
			else:
				samples1 = np.array(output, dtype = np.complex128);

			if event.isSet():
				event.clear()
				if not self.alive:
					break;
				event.wait()
			else:
				self.save2mat(x)
				self.timestamp = int(time.time());
				print '*'*3+' '+str(x)+' done: '+time.asctime( time.localtime(time.time()) );
				if not self.alive:
					break;
				event.set()
	def save2mat(self, i):
		global samples0, samples1;
		std0 = np.around(np.std(samples0), 5);
		std1 = np.around(np.std(samples1), 5);
		print 'std0:', std0, 'std1', std1;

		scipy.io.savemat('./data/'+folder_name+'/'+filename+'_'+str(i)+'.mat', mdict={'s0':samples0, 's1':samples1, 'timestamp': self.timestamp, 'fs':self.sdr.sample_rate, 'ref_addr':ref_addr});
Esempio n. 56
0
def collect_samples(freq, classname):
    os.makedirs("training_data/" + classname, exist_ok=True)
    os.makedirs("testing_data/" + classname, exist_ok=True)
    for i in range(0, 1000):
        iq_samples = read_samples(sdr, freq)
        iq_samples = signal.decimate(iq_samples, decimation_rate, zero_phase=True)
        if (i < 750):  # 75% train, 25% test
            filename = "training_data/" + classname + "/samples-" + randomword(16) + ".npy"
        else:
            filename = "testing_data/" + classname + "/samples-" + randomword(16) + ".npy"
        np.save(filename, iq_samples)
        if not (i % 10): print(i / 10, "%", classname)


sdr = RtlSdr()
sdr.sample_rate = sample_rate = 2400000
decimation_rate = 48
sdr.err_ppm = 56   # change it to yours
sdr.gain = 'auto'

# collect_samples(422600000, "tetra")
collect_samples(95000000, "wfm")
collect_samples(104000000, "wfm")
collect_samples(942200000, "gsm")
collect_samples(147337500, "dmr")
collect_samples(49250000, "tv")

# collect "other" class training data
for freq in range(112000000, 174000000, 50000):
    print('Sampling at', freq)
Esempio n. 57
0
def main():
    # Setup cli arguments
    parser = argparse.ArgumentParser(
        description=
        '''Listen for ADS-B signals using an RTL-SDR and watch the air traffic on local Dash webserver! Default location is http://localhost:8050'''
    )
    parser.add_argument(
        '--rtl_device',
        '-d',
        type=int,
        default=0,
        metavar='device_index',
        help='Select the RTL-SDR device index to use. Defaults to device 0.')
    parser.add_argument(
        '--location',
        '-l',
        type=float,
        nargs=2,
        metavar=('Lat', 'Lon'),
        default=(None, None),
        help=
        'Set the latitude and longitude of your ground station; usually your current location. If unset, attempts to determine your location using your IP address.'
    )
    parser.add_argument(
        '--TTL',
        '-t',
        type=int,
        default=100,
        help=
        "Delete a tracked object if we haven't heard from it for TTL seconds. Default to 100 seconds."
    )
    parser.add_argument(
        '--port',
        '-p',
        type=int,
        default=8050,
        help=
        'The local port to run the Dash webserver on. Default to port 8050.')
    parser.add_argument(
        '--log',
        type=str,
        default=None,
        help=
        'Where to log information on detected ADS-B packets. Does not log if unset.'
    )
    parser.add_argument(
        '--fix-single-bit-errors',
        type=str,
        default='No',
        metavar='[Y/N]',
        dest='fix_single_bit_errors',
        help=
        'Have the decoder attempt to fix single bit errors in packets. VERY RESOURCE INTENSIVE AT THIS TIME!!!'
    )
    args = parser.parse_args()

    # Variable initialization
    fs = 2000000
    # 2MHz sampling frequency
    center_freq = 1090e6  # 1090 MHz center frequency
    gain = 49.6  # Gain
    N_samples = 2048000  # SDR samples for each chunk of data ( Approx 1.024 seconds per chunk )
    TTL = args.TTL  # How long to store ADS-B object information
    log = args.log  # Where to log packets

    # Determine ground station location using IP address or manual input
    if args.location[0] == None or args.location[1] == None:
        try:
            url = 'https://ipinfo.io'
            loc_request = requests.get(url)
            lat_lon = loc_request.json()['loc'].split(',')
            pos_ref = [float(lat_lon[0]), float(lat_lon[1])]
        except Exception:
            print(f'Error requesting location information from {url}')
            exit()
    else:
        pos_ref = [args.location[0], args.location[1]]

    # Determine whether to fix 1-bit errors
    FIX_1BIT_ERRORS = (args.fix_single_bit_errors[0] == 'Y'
                       or args.fix_single_bit_errors[0] == 'y'
                       or args.fix_single_bit_errors[0] == '1'
                       or args.fix_single_bit_errors[0] == 'T'
                       or args.fix_single_bit_errors[0] == 't')

    # Setup Dash server
    app.server(pos_ref, planes, packets)

    # Create a queue for communication between the reading and processing threads
    Qin = queue.Queue()

    # Setup the RTL-SDR reader
    sdr = RtlSdr(args.rtl_device)
    sdr.sample_rate = fs  # sampling rate
    sdr.center_freq = center_freq  # 1090MhZ center frequency
    sdr.gain = gain

    stop_flag = threading.Event()

    # Setup the reading and processing threads
    t_sdr_read = threading.Thread(target=sdr_read,
                                  args=(Qin, sdr, N_samples, stop_flag))
    t_signal_process = threading.Thread(target=signal_process,
                                        args=(Qin, source, stop_flag, log,
                                              pos_ref, FIX_1BIT_ERRORS))

    t_sdr_read.start()
    t_signal_process.start()

    # Run the Dash web server
    app.app.run_server(port=args.port)

    # Run until the threads stop
    while threading.active_count() > 0:
        try:
            time.sleep(0.1)
        except:
            print("Stopping threads...")
            stop_flag.set()
            raise
            exit()
Esempio n. 58
0
    def listen(self, sdr):
        try:
            loop = asyncio.get_event_loop()
            loop.run_until_complete(client.streaming(sdr))
        except KeyboardInterrupt:
            raise SystemExit("Stopped Listening for the Remote Signal!")


# Added a Proper Entry Point I Guess
if __name__ == "__main__":
    # Start SDR
    try:
        device = 0

        # Get a list of detected device serial numbers (str)
        devices = RtlSdr.get_device_serial_addresses()
        print("Devices: " + str(devices))
        if len(devices) is 0: raise Exception("No Detected RTLSDR Devices!!!")
        # Find the device index for a given serial number
        device_index = RtlSdr.get_device_index_by_serial(
            devices[device]
        )  # You can insert your Serial Address (as a string) directly here
        sdr = RtlSdr(device_index)
        #sdr = RtlSdr() # If you don't have more than 1 device, this will work fine.
    except OSError:
        print("Could Not Find RTLSDR!!! Is It Locked???")
        sys.exit(2)
    except IndexError:
        print("Choose a Valid Device ID!!!")
        sys.exit(2)
    except Exception as error:
Esempio n. 59
0
Fs = 2.048e6
Fo = 101.723e6

if len(sys.argv) > 1:
    print(sys.argv[1])
    Fo = float(sys.argv[1] + 'e6')

fm = Demodulador(Fs, Fo)
output_Fs = fm.outputFs()

p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16,
                channels=1,
                rate=output_Fs,
                output=True)
sdr = RtlSdr()
sdr.sample_rate = Fs  # Hz
sdr.center_freq = Fo  # Hz
sdr.freq_correction = 60  # PPM
sdr.gain = 'auto'

STOP_FLAG = False


async def streaming():
    elapsed_time = time.time()
    async for samples in sdr.stream(num_samples_or_bytes=10240000):
        audio = np.int16(fm.demodular(samples) * 32767)
        stream.write(audio)
        if STOP_FLAG:
            await sdr.stop()
Esempio n. 60
0
class RTLSdr:
    def __init__(self, **args):
        self.logcl = LogCL()
        self.import_rtlsdr()
        self.import_pylab()
        self.set_static_dir()
        self.set_args(args)
        self.dev = None
        self.dev_open = False
        self.sensivity = 3
        self.stop_func = None

    def set_static_dir(self):
        full_path = os.path.realpath(__file__)
        self.static_dir = os.path.split(full_path)[0] + '/static/'

    def set_args(self, args):
        try:
            self.dev_id = int(args['dev'])
            self.sample_rate = int(args['samprate'])
            self.gain = args['gain']
            self.center_freq = args['freq']
            self.num_read = int(args['n'])
            self.interval = int(args['i'])
            self.args = args
        except Exception as e:
            self.logcl.log("Invalid argument detected.\n" + str(e), 'error')
            sys.exit()
    
    def import_rtlsdr(self):
        try:
            self.logcl.log("Importing rtlsdr module...")
            global RtlSdr
            from rtlsdr import RtlSdr
        except:
            self.logcl.log("rtlsdr module not found.", "error")
    
    def import_pylab(self):
        try:
            global plt, np, peakutils
            import pylab as plt
            import numpy as np
            import peakutils
        except Exception as e:
            if 'peak' in str(e):
                self.logcl.log("peakutils module not found.\n" + str(e), 'error')
            else:
                self.logcl.log("matplotlib module not found.\n" + str(e), 'error')
            sys.exit()

    def init_device(self, init_dev=True, show_log=True):
        try:
            if show_log: 
                self.logcl.log("Trying to open & initialize device #" + str(self.dev_id))
            self.dev = RtlSdr(self.dev_id)
            self.dev_open = True
            if init_dev:
                self.dev.center_freq = self.center_freq
                self.dev.sample_rate = self.sample_rate
                self.dev.gain = self.gain
        except IOError as e:
            self.dev_open = False
            if init_dev:
                self.logcl.log("Failed to open RTL-SDR device!\n" + str(e), 'error')
        except Exception as e:
            self.logcl.log("Failed to initialize RTL-SDR device.\n" + str(e), 'fatal')
        return self.dev_open

    def read_samples(self, n_read=512*512):
        try:
            if not self.dev.device_opened:
                if not self.stop_func == None:
                    self.dev_open = False
                    self.stop_func()
            else:
                return self.dev.read_samples(n_read)
        except Exception as e:
            self.logcl.log("Failed to read samples from RTL-SDR.\n" + str(e), 'error')

    def close(self, show_log=False):
        try:
            if show_log:
                self.logcl.log("Closing RTL-SDR device #" + str(self.dev_id))
            if self.dev != None:
                self.dev.close()
                self.dev_open = False
        except Exception as e:
            self.logcl.log("Failed to close RTL-SDR device.\n" + str(e), 'error')
            
    def find_peaks(self, plt, Y, F, n):
        try:
            freqs = []
            dbs = []
            indexes = peakutils.indexes(Y, thres=abs(11-(n))/10, min_dist=20)
            for index in indexes:
                freq = F[index]
                db = 10 * math.log10(Y[index])
                freqs.append(freq)
                dbs.append(db)
                plt.plot(freq, db, 
                    color='k', 
                    marker='x', 
                    markersize=6, 
                    linestyle='None')
            return [freqs, dbs]
        except:
            self.logcl.log("Failed to find peaks on graph.\n" + str(e), 'error')

    def get_fft_data(self, scan=False):
        try:
            [Y, F] = plt.psd(self.read_samples(), NFFT=1024, Fs=int(self.sample_rate)/1e6, \
                    Fc=int(self.center_freq)/1e6, color='k')    
            if scan: max_freqs = self.find_peaks(plt, Y, F, n=self.sensivity)
            plt.xlabel('Frequency (MHz)')
            plt.ylabel('Relative power (dB)')
            plt.savefig(self.static_dir + '/img/fft.png', bbox_inches='tight', pad_inches = 0)
            plt.clf()
            encoded = base64.b64encode(open(self.static_dir + '/img/fft.png', "rb"). \
                    read()).decode("utf-8")
            return encoded if not scan else [encoded, max_freqs]
        except Exception as e:
            self.logcl.log("Failed to get graph data.\n" + str(e), 'error')