Esempio n. 1
0
class SDRThread(QThread):
    signal = pyqtSignal(object)

    def __init__(self,
                 sample_rate=2.4e6,
                 center_freq=100.0e6,
                 freq_correction=60,
                 gain=33.8,
                 chunks=1024):
        QThread.__init__(self)

        # configure device
        try:
            self.sdr = RtlSdr()
        except LibUSBError:
            print("No Hardware Detected")
            self.isRunning = False

        else:
            self.sdr.sample_rate = sample_rate  # Hz
            self.sdr.center_freq = center_freq  # Hz
            self.sdr.freq_correction = freq_correction  # PPM
            self.sdr.gain = gain  # dB
            self.isRunning = True

        self.CHUNK = chunks

    def __del__(self):
        if self.isRunning:
            self.wait()

    def stop_thread(self):
        self.isRunning = False
        self.sdr.cancel_read_async()
        self.sdr.close()

    def sdr_tune(self, cf):
        self.sdr.center_freq = cf  # Hz

    def sdr_gain(self, gain=33.8):
        self.sdr.gain = gain

    def run(self):
        if self.isRunning:
            self.sdr.read_samples_async(self.sdr_async_callback, self.CHUNK,
                                        None)

    def sdr_async_callback(self, iq, ctx):
        power, _ = mlab.psd(iq,
                            NFFT=self.CHUNK,
                            Fs=self.sdr.sample_rate,
                            scale_by_freq=False)
        self.signal.emit(np.sqrt(power))
Esempio n. 2
0
class FMRadio(QtGui.QMainWindow,Ui_MainWindow):
    sample_buffer = Queue.Queue(maxsize=10)
    base_spectrum = np.ones(5780)

    plotOverall = True
    plotChannel = False
    plotPlaying = False
    plotWaveform = False
    useStereo = False
    stereoWidth = 10
    useMedianFilt = True
    useLPFilt = True
    demodFiltSize = 100000
    useAudioFilter = True
    audioFilterSize = 16
    toDraw = True
    demodMain = True
    demodSub1 = False
    demodSub2 = False
    toDrawWaterfalls = True
    toDrawPlots = False

    prevCutoff = 0
    prevSpec1 = np.zeros(128)
    prevSpec2 = np.zeros(128)
    prevSpec3 = np.zeros(128)
    prevConvo1 = np.zeros(128)
    prevConvo2 = np.zeros(128,dtype='complex')

    limiterMax = np.zeros(32)

    toPlot = (np.cumsum(np.ones(5780)),np.cumsum(np.ones(5780)))

    def __init__(self,freq,N_samples):
        self.spectrogram = np.zeros((512,400))
        self.chspectrogram = np.zeros((512,400))
        self.plspectrogram = np.zeros((256,400))
        self.cur_spectrogram = self.spectrogram


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

        self.createQtConnections()
        ftxt = "%.1f MHz" % (freq/1e6)
        self.ui.curFreq.setText(ftxt)

        self.sample_rate = 2.4e5 # tried 1.024e6 - not so great
        self.decim_r1 = 1 # 1.024e6/2.4e5 # for wideband fm down from sample_rate
        self.decim_r2 = 2.4e5/48000 # for baseband recovery
        self.center_freq = freq #+250e3
        self.gain = 16

        self.N_samples = N_samples
        self.is_sampling = False



        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)

        self.PLL = PhaseLockedLoop(self.N_samples,19000,self.sample_rate)

        self.initOpenCV()

        self.noisefilt = np.ones(6554)
        b,a = signal.butter(1, 2122/48000*2*np.pi, btype='low')
        self.demph_zf = signal.lfilter_zi(b, a)

        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)

    # Not currently used
    def getSamples(self):
        return self.sdr.read_samples(self.N_samples);

    def getSamplesAsync(self):
        #Asynchronous call. Initiates a continuous loop with the callback fn
        self.is_sampling = True
        samples = self.sdr.read_samples_async(self.sampleCallback,self.N_samples,context=self)
    def sampleCallback(self,samples,sself):

        self.is_sampling = False
        self.sample_buffer.put(samples)
        #print 'put some samples in the jar'

        # recursive loop
        #sself.getSamplesAsync()

    def demodulate_th(self):
        # Initiates a loop to process all the incoming blocks of samples from the Queue
        # This should be run in its own thread, or the program will become unresponsive
        while(1):

            try:
                samples = self.sample_buffer.get()
                #samples2 = self.sample_buffer.get()
            except:
                #print "wtf idk no samples?"  # even though this can't happen... (although I'm not sure why not)
                #print 'gonna try to finish off the to-do list'
                #self.sample_buffer.join()
                break

            out1 = self.demodulate(samples)
            self.sample_buffer.task_done()
            #out2 = self.demodulate(samples2)
            #self.sample_buffer.task_done()

            audio_out = out1 #np.append(out1,out2)
            self.play(audio_out)

    def gen_spectrogram(self,x,m,prevSpec):
        itsreal = np.isreal(x[0])

        m = int(m)
        lx = x.size
        nt = (lx) // m
        #NT = (lx +m -1)//m
        #padsize = NT*m -lx
        cutsize = lx -nt*m
        padsize = int(cutsize + m/2)


        if not prevSpec.size == padsize:
            prevSpec = np.zeros(padsize)

        xp = np.append(x[cutsize:],prevSpec)
        prevSpec = x[:(padsize)]

        xh = np.zeros((m,nt*2), dtype='complex')
        for n in range(int(nt*2)):
            block = xp[m*n//2:m*(n+2)//2]

            xh[:,n] = block*np.hanning(block.size)


        #if self.prevSpec.size == padsize:
        #    xb = np.append(self.prevSpec[:prevSpec.size-m/2],x)
        #    xc = np.append(self.prevSpec,x[:lx-m/2])
        #    self.prevSpec = x[lx-m/2:]
        #else:

        #    xb = np.append(x,np.zeros(-lx+nt*m))
        #    xc = np.append(x[m/2:],np.zeros(nt*m - lx + m/2))


        #xr = np.reshape(xb, (m,nt), order='F') * np.outer(np.hanning(m),np.ones(nt))
        #xs = np.reshape(xc, (m,nt), order='F') * np.outer(np.hanning(m),np.ones(nt))

        #xm = np.zeros((m,2*nt),dtype='complex')
        #xm[:,::2] = xr
        #xm[:,1::2] = xs

        if itsreal:
            spec = np.fft.fft(xh,m,axis=0)
            spec = spec[:m//2,:]
        else:
            spec = np.fft.fftshift(np.fft.fft(xh,m,axis=0))
        #mx = np.max(spec)

        pwr = np.log(np.abs(spec) + 1e-6)

        return (np.real(pwr),prevSpec)

    def initOpenCV(self):
        cv2.namedWindow("Spectrogram")

    def demodulate(self,samples):
        # DEMODULATION CODE - And the core function
        # samples must be passed in by the caller
        self.count += 1

        #spectral_window = signal.hanning

        #spectrum = np.fft.fftshift(np.fft.fft(samples*spectral_window(samples.size)))

        self.spectrogram = np.roll(self.spectrogram, 16,axis=1)
        stft,self.prevSpec1 = self.gen_spectrogram(samples,samples.size//8,self.prevSpec1)
        self.spectrogram[:,:16] = stft[::8,:]     # np.log(np.abs(spectrum[::100]))

        if(self.plotOverall): # and self.count % 10 == 9):
            #self.drawSpectrum()
            self.cur_spectrogram = self.spectrogram
            self.drawCurSpectrum()

#         cutoff = self.demodFiltSize
#         h = signal.firwin(128, cutoff,nyq=self.sample_rate/2)
#         lp = signal.fftconvolve(samples[::self.decim_r1],h,mode='full')
#         lps = lp.size
#         hs = h.size
#         prev = lp[lps-hs:]
#         lp[:hs/2] += self.prevConvo2[hs/2:]
#         lp = np.append(self.prevConvo2[:hs/2],lp)
#         self.prevConvo2 = prev
#         lp_samples = lp[:lps-hs+1]
        lp_samples = samples

        power = np.abs(self.mad(lp_samples))
        self.ui.signalMeter.setValue(20*(np.log10(power)))


    # polar discriminator

        dphase = np.zeros(lp_samples.size, dtype='complex')

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

        dphase[1:] = ( A * np.conj(B) )

        dphase[0] = lp_samples[0] * np.conj(self.prevCutoff) #dphase[dphase.size-2]
        self.prevCutoff = lp_samples[lp_samples.size-1]

    # limiting

        dphase /= np.abs(dphase)

#         if self.useMedianFilt:
#             rebuilt = signal.medfilt(np.angle(dphase)/np.pi,self.demodFiltSize) #  np.cos(dphase)
#         else:
#             rebuilt = self.lowpass(np.angle(dphase),self.demodFiltSize)

        rebuilt = np.real(np.angle(dphase) / np.pi)



        demodMain = False
        demodSub1 = False
        demodSub2 = False
        isStereo = False
        if self.demodMain:
            demodMain = True
            if self.useStereo:
                isStereo = True
        elif self.demodSub1:
            demodSub1 = True
        elif self.demodSub2:
            demodSub2 = True

        #spectrum = np.fft.fft(rebuilt* spectral_window(rebuilt.size))
        #print rebuilt.size/8
        self.chspectrogram = np.roll(self.chspectrogram, 16,axis=1)
        stft,self.prevSpec2 = self.gen_spectrogram(rebuilt,rebuilt.size/8,self.prevSpec2)
        self.chspectrogram[:,:16] = stft[::-4,:]                          # np.log(np.abs(spectrum[spectrum.size/2:spectrum.size:50]))
        if(self.plotChannel):# and self.count % 10 == 9):
            self.cur_spectrogram = self.chspectrogram
            self.drawCurSpectrum()
             #plotspectrum = np.abs(channel_spectrum[::100])
             #self.toPlot = (np.linspace(-np.pi,np.pi,plotspectrum.size),plotspectrum)
             #self.replot()


        n_z = rebuilt.size
        if demodMain:

            h = signal.firwin(128,16000,nyq=1.2e5)
            output = signal.fftconvolve(rebuilt,h,mode='full')
            outputa = output    # could be done in place but I'm not concerned with memory

            outputa[:h.size/2] += self.prevConvo1[h.size/2:]   #add the latter half of tail end of the previous convolution
            outputa = np.append(self.prevConvo1[:h.size/2], outputa) # also delayed by half size of h so append the first half

            self.prevConvo1 = output[output.size-h.size:]   # set the tail for next iteration

            output = outputa[:output.size-h.size:self.decim_r2]  # chop off the tail and decimate


            #stereo_spectrum = spectrum
            if isStereo:

                #pilot = rebuilt * np.cos(2*np.pi*19/240*(np.r_[0:rebuilt.size]))
                h = signal.firwin(512,[18000,20000],pass_zero=False,nyq=1.2e5)
                pilot_actual = signal.fftconvolve(rebuilt,h,mode='same')
                self.PLL.adjust(pilot_actual)


                moddif = rebuilt * np.real(np.square(self.PLL.pll)) #np.cos(2*np.pi*38/240*(np.r_[0:ss] - phase_shift))
                h = signal.firwin(128,16000,nyq=1.2e5)
                moddif = signal.fftconvolve(moddif,h,mode='same')

                h = signal.firwin(64,16000,nyq=48000/2)
                diff = signal.fftconvolve(moddif[::self.decim_r2],h,mode='same')
                diff = np.real(diff)
#                 rdbs = rebuilt * np.power(self.PLL.pll,3)
#                 h = signal.hanning(1024)
#                 rdbs = signal.fftconvolve(rdbs,h)
#                 if np.mean(rdbs) > 0:
#                     # bit ONE
#                 else:
#                     # bit ZERO

        elif demodSub1:


            demod = rebuilt * np.exp(-2j*np.pi*67650/2.4e5*np.r_[0:rebuilt.size])

            h = signal.firwin(128,7500,nyq=2.4e5/2)
            lp_demod = signal.fftconvolve(demod,h,mode='same')
            decim = lp_demod[::self.decim_r2]


            dphase = np.zeros(decim.size, dtype='complex')
#
            A = decim[1:decim.size]
            B = decim[0:decim.size-1]
#
            dphase[1:] = np.real(np.angle( A * np.conj(B) ))
            h = signal.firwin(128,7500,nyq=24000)
            output = signal.fftconvolve(dphase,h,mode='same')


        elif demodSub2:
            demod = rebuilt * np.exp(-2j*np.pi*92000/2.4e5*np.r_[0:rebuilt.size])

            h = signal.firwin(128,7500,nyq=2.4e5/2)
            lp_demod = signal.fftconvolve(demod,h,mode='same')
            decim = lp_demod[::self.decim_r2]


            dphase = np.zeros(decim.size, dtype='complex')
#
            A = decim[1:decim.size]
            B = decim[0:decim.size-1]
#
            dphase[1:] = np.real(np.angle( A * np.conj(B) ))
            h = signal.firwin(128,7500,nyq=24000)
            output = signal.fftconvolve(dphase,h,mode='same')

        # DC block filter, lol, srsly
        output = np.real(output) - np.mean(np.real(output))

        if np.isnan(output[0]):
            #print "error" # for some reason, output is NaN for the first 2 loops
            return np.zeros(6554)

        # deemphasis - # 2122/samplerate*2 *pi  - butterworth filter
        b,a = signal.butter(1, 2122/48000*2*np.pi, btype='low')
        output, zf = signal.lfilter(b, a, output,zi=self.demph_zf)
        self.demph_zf = zf

        stereo = np.zeros(output.size*2)
        if (isStereo):

            diff = signal.lfilter(b,a,diff)
            w = self.stereoWidth  # adjust to change stereo wideness
            left = output + w/10 * diff
            right = output - w/10 * diff

            if(self.useAudioFilter):
                left = self.lowpass(left,self.audioFilterSize)
                right = self.lowpass(right,self.audioFilterSize)

            stereo[0:stereo.size:2] = left
            stereo[1:stereo.size:2] = right
        else:
            if self.useAudioFilter:
                output = self.lowpass(output,self.audioFilterSize) # just the tip (kills the 19k pilot)
            stereo[0:stereo.size:2] = output
            stereo[1:stereo.size:2] = output

        #normalize to avoid any possible clipping when playing
        stereo /= 2*np.max(stereo)
        #spectrum = np.fft.fft(stereo[::2])
        output = .5*(stereo[::2]+stereo[1::2])

        #spectrum = np.fft.fft(.5*(stereo[::2]+stereo[1::2])*spectral_window(output.size))
        self.plspectrogram = np.roll(self.plspectrogram, 24,axis=1)
        stft,self.prevSpec3 = self.gen_spectrogram(output,512,self.prevSpec3)
        self.plspectrogram[:,:24] = stft[::-1,:]  # np.log(np.abs(spectrum[spectrum.size/2:spectrum.size:20]))
        if(self.plotPlaying): # and self.count % 2 == 0):
            #if self.toDrawWaterfalls:
            self.cur_spectrogram = self.plspectrogram
            self.drawCurSpectrum(invert=True)

                #self.drawPlspectrum()
            #else:

            #    sm = np.abs(np.fft.fftshift(spectrum[::20]))
            #    toPlot = (np.linspace(-2.4e4,2.4e4,sm.size),sm)
            #    self.replot(toPlot)


        #if(self.toDraw and self.plotWaveform):
        #    if self.toDrawWaterfalls:
        #        sm = np.real(output[::20])
        #        toPlot = (np.linspace(0,output.size/48000,sm.size),sm)
        #        self.replot(toPlot)
        #    else:
        #        sm = np.real(self.PLL.pll[::200])
        #        toPlot = (np.linspace(0,output.size/48000,sm.size),sm)
        #        self.replot(toPlot)

        return np.real(stereo)


    # Alternate demodulator. Not used, but extremely simple
    def demodulate2(self,samples):
        # DEMODULATION CODE

        # LIMITER goes here

        # low pass & down sampling
        h = signal.firwin(128,80000,nyq=1.2e5)
        lp_samples = signal.fftconvolve(samples, h)

    # polar discriminator

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

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

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

        h = signal.firwin(128,16000,nyq=1.2e5)
        rebuilt = signal.fftconvolve(dphase,h)

        output = rebuilt[::self.decim_r2]

        output = self.lowpass(output, self.audioFilterSize)

        return np.real(output)

# utility functions #

    def lowpass(self,x,width):
        #wndw = np.sinc(np.r_[-15:16]/np.pi)/np.pi
        #wndw = np.kaiser(width,6)
        wndw = signal.firwin(16,width*999,nyq=24000)
        #wndw /= np.sum(wndw)
        new_array = signal.fftconvolve(x, wndw, mode='same')

        return new_array

    # calculate mean average deviation #
    def mad(self,samples):
        ave = np.mean(samples)
        return np.mean(np.abs(samples-ave))

    # 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() )


    # starting point
    def start(self):
        # Initiates running things
        self.streamer = MakeDaemon(self.demodulate_th) # run demodulation in the 'background'
        self.streamer.start()
        self.count = 0
        self.sampler_t = threading.Thread(target=self.getSamplesAsync) # sampler loop
        self.sampler_t.start()


    def createQtConnections(self):

        QtCore.QObject.connect(self.ui.freqSelect, QtCore.SIGNAL(_fromUtf8("valueChanged(int)")), self.setFreq)
        QtCore.QObject.connect(self.ui.checkBox, QtCore.SIGNAL(_fromUtf8("toggled(bool)")), self.setUseStereo)
        QtCore.QObject.connect(self.ui.mainchannel, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDemodMain)
        QtCore.QObject.connect(self.ui.subband1, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDemodSub1)
        QtCore.QObject.connect(self.ui.subband2, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDemodSub2)
        QtCore.QObject.connect(self.ui.stereoWidthSlider, QtCore.SIGNAL(_fromUtf8("sliderMoved(int)")), self.setStereoWidth)
        QtCore.QObject.connect(self.ui.spectrum_overall, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setSpectrumOverall)
        QtCore.QObject.connect(self.ui.spectrum_channel, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setSpectrumChannel)
        QtCore.QObject.connect(self.ui.spectrum_playing, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setSpectrumPlaying)
        QtCore.QObject.connect(self.ui.spectrum_waveform, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setSpectrumWaveform)
        QtCore.QObject.connect(self.ui.demodFiltMedian, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDemodFiltMedian)
        QtCore.QObject.connect(self.ui.demodFiltLP, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDemodFiltLP)
        QtCore.QObject.connect(self.ui.demodFilterSize, QtCore.SIGNAL(_fromUtf8("sliderMoved(int)")), self.setDemodFiltSize)
        QtCore.QObject.connect(self.ui.audioFilterActive, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setAudioFiltUse)
        QtCore.QObject.connect(self.ui.audioFilterSizeSlider, QtCore.SIGNAL(_fromUtf8("sliderMoved(int)")), self.setAudioFiltSize)
        QtCore.QObject.connect(self.ui.exitButton, QtCore.SIGNAL(_fromUtf8("clicked()")), self.terminate)
        QtCore.QObject.connect(self.ui.drawPlot, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDrawSpec)
        QtCore.QObject.connect(self.ui.waterfallButton, QtCore.SIGNAL(_fromUtf8('toggled(bool)')), self.setDrawWaterfalls)
      #  QtCore.QObject.connect(self.ui.plotButton, QtCore.SIGNAL(_fromUtf8("clicked(bool)")), self.setDrawPlot)

        self.bindPlot()


    def bindPlot(self):
        self.dpi = 100
        self.fig = Figure((4.31,2.0), dpi=self.dpi)
        self.canvas = FigureCanvas(self.fig)
        self.canvas.setParent(self.ui.plotFrame)

        self.initplot()


    def initplot(self):
        self.axes = self.fig.add_subplot(111, aspect=200/431)
        self.axes.xaxis.set_major_locator(ticker.NullLocator())
        self.axes.yaxis.set_major_locator(ticker.NullLocator())
        self.fig.tight_layout()
        #self.axes.invert_yaxis()

        #self.anim = animation.FuncAnimation(self.fig,self.drawCurSpectrum,interval=750)


    def replot(self,toPlot):
        self.axes.clear()
        self.axes.plot(toPlot[0],toPlot[1])
        self.axes.set_aspect('auto',anchor='C')
        self.canvas.draw()

    def setDrawSpec(self,s):
        self.toDraw = s

    def drawCurSpectrum(self,invert=False):
        #self.axes.clear()
        #self.axes.imshow(self.cur_spectrogram, cmap='spectral')
        #self.axes.xaxis.set_major_locator(ticker.NullLocator())
        #self.axes.yaxis.set_major_locator(ticker.NullLocator())
        #self.axes.set_aspect('auto',adjustable='box',anchor='NW')
        #self.canvas.draw()
        mx = np.max(self.cur_spectrogram)
        mn = np.min(self.cur_spectrogram)
        if invert:
            self.cur_spectrogram = -cv2.convertScaleAbs(self.cur_spectrogram,alpha=255 / (mx))
        else:
            self.cur_spectrogram = cv2.convertScaleAbs(self.cur_spectrogram,alpha=255 / (mn))
        self.cur_spectrogram = cv2.GaussianBlur(self.cur_spectrogram,(5,5),.6)
        cmapped =cv2.applyColorMap(self.cur_spectrogram,cv2.COLORMAP_JET)
        cv2.imshow('Spectrogram',cmapped)
        cv2.waitKey(1);

    def drawSpectrum(self):
        self.axes.clear()
        self.axes.imshow(self.spectrogram, cmap='spectral')
        self.axes.xaxis.set_major_locator(ticker.NullLocator())
        self.axes.yaxis.set_major_locator(ticker.NullLocator())
        self.axes.set_aspect('auto',adjustable='box',anchor='NW')
        self.canvas.draw()

    def drawChspectrum(self):
        self.axes.clear()
        self.axes.imshow(self.chspectrogram, cmap='spectral')
        self.axes.xaxis.set_major_locator(ticker.NullLocator())
        self.axes.yaxis.set_major_locator(ticker.NullLocator())
        self.axes.set_aspect('auto',adjustable='box',anchor='NW')
        self.canvas.draw()

    def drawPlspectrum(self):
        self.axes.clear()
        self.axes.imshow(self.plspectrogram, cmap='spectral')
        self.axes.xaxis.set_major_locator(ticker.NullLocator())
        self.axes.yaxis.set_major_locator(ticker.NullLocator())
        self.axes.set_aspect('auto',adjustable='box',anchor='NW')
        self.canvas.draw()

    def setDrawPlots(self,s):

        self.toDrawPlots = s
        self.toDrawWaterfalls = not s

    def setDrawWaterfalls(self,s):

        self.toDrawWaterfalls = s
        self.toDrawPlots = not s

    def setFreq(self,freq):
        if freq % 2 == 0:
            freq += 1
        freq /= 10.0
        text = "%.1f MHz" % freq
        self.ui.curFreq.setText(text)
        self.center_freq = freq*1e6 #+ 250e3
        setf_t = threading.Thread(target=self.setF_th, args=[self.center_freq,])
        setf_t.start()
        setf_t.join()



    # This function is what is used to adjust the tuner on the RTL
    # Currently, it causes the program to crash if used after an unspecified period of inactivity
    #     commented lines are attempts that didn't work
    def setF_th(self,f):
        while(self.is_sampling == True):
            pass
        #self.sdr.cancel_read_async()
        time.sleep(.1)
        self.sdr.center_freq = f
        #self.getSamplesAsync()

    def setUseStereo(self,u):
        self.useStereo = u
    def setStereoWidth(self,w):
        self.stereoWidth = w/5

    def setDemodMain(self,s):
        self.demodMain = s
        self.demodSub1 = not s
        self.demodSub2 = not s
        #self.useStereo = True
    def setDemodSub1(self,s):
        self.demodMain = not s
        self.demodSub1 = s
        self.demodSub2 = not s
        #self.useStereo = False
    def setDemodSub2(self,s):
        self.demodMain = not s
        self.demodSub1 = not s
        self.demodSub2 = s
        #self.useStereo = False

    def setSpectrumOverall(self,s):
        #self.initplot()
        #self.cur_spectrogram = self.spectrogram
        self.plotOverall = s
        self.plotChannel = not s
        self.plotPlaying = not s
        self.plotWaveform = not s
    def setSpectrumChannel(self,s):
        #self.initplot()
        self.plotChannel = s
        self.plotOverall = not s
        self.plotPlaying = not s
        self.plotWaveform = not s
    def setSpectrumPlaying(self,s):
        #self.initplot()
        self.plotPlaying = s
        self.plotChannel = not s
        self.plotOverall= not s
        self.plotWaveform = not s
    def setSpectrumWaveform(self,s):
        self.plotWaveform = s
        self.plotPlaying = not s
        self.plotChannel = not s
        self.plotOverall= not s

    def setDemodFiltMedian(self,s):
        self.useMedianFilt = s
        self.useLPFilt = not s
    def setDemodFiltLP(self,s):
        self.useLPFilt = s
        self.useMedianFilt = not s
    def setDemodFiltSize(self,s):
        #if(s % 2 == 0):
        #    s+=1
        self.demodFiltSize = s

    def setAudioFiltUse(self,s):
        self.useAudioFilter = s
    def setAudioFiltSize(self,s):
        self.audioFilterSize = s

    def terminate(self):
        self.__del__()

    # Destructor - also used to exit the program when user clicks "Quit"
    def __del__(self):

        # Program will continue running in the background unless the RTL is told to stop sampling
        self.sdr.cancel_read_async()
        print "sdr closed"
        self.sdr.close()
        print "pyaudio terminated"
        self.pa.terminate()
        cv2.destroyAllWindows()
Esempio n. 3
0
class RtlReader(object):
    def __init__(self, **kwargs):
        super(RtlReader, self).__init__()
        self.signal_buffer = []
        self.sdr = RtlSdr()
        self.sdr.sample_rate = modes_sample_rate
        self.sdr.center_freq = modes_frequency
        self.sdr.gain = "auto"
        # sdr.freq_correction = 75

        self.debug = kwargs.get("debug", False)
        self.raw_pipe_in = None
        self.stop_flag = False

    def _process_buffer(self):
        messages = []

        # signal_array = np.array(self.signal_buffer)
        # pulses_array = np.where(np.array(self.signal_buffer) < th_amp, 0, 1)
        # pulses = "".join(str(x) for x in pulses_array)
        buffer_length = len(self.signal_buffer)

        i = 0
        while i < buffer_length:
            if self.signal_buffer[i] < th_amp:
                i += 1
                continue

            # if pulses[i : i + pbits * 2] == preamble:
            if self._check_preamble(self.signal_buffer[i : i + pbits * 2]):
                frame_start = i + pbits * 2
                frame_end = i + pbits * 2 + (fbits + 1) * 2
                frame_length = (fbits + 1) * 2
                frame_pulses = self.signal_buffer[frame_start:frame_end]

                msgbin = ""
                for j in range(0, frame_length, 2):
                    p2 = frame_pulses[j : j + 2]
                    if len(p2) < 2:
                        break

                    if p2[0] < th_amp and p2[1] < th_amp:
                        break
                    elif p2[0] >= p2[1]:
                        c = "1"
                    elif p2[0] < p2[1]:
                        c = "0"
                    else:
                        msgbin = ""
                        break
                    msgbin += c

                # advance i with a jump
                i = frame_start + j

                if len(msgbin) > 0:
                    msghex = pms.bin2hex(msgbin)
                    if self._check_msg(msghex):
                        messages.append([msghex, time.time()])
                    if self.debug:
                        self._debug_msg(msghex)

            elif i > buffer_length - 500:
                # save some for next process
                break
            else:
                i += 1

        # keep reminder of buffer for next iteration
        self.signal_buffer = self.signal_buffer[i:]
        return messages

    def _check_preamble(self, pulses):
        if len(pulses) != 16:
            return False

        for i in range(16):
            if abs(pulses[i] - preamble[i]) > th_amp_diff:
                return False

        return True

    def _check_msg(self, msg):
        df = pms.df(msg)
        msglen = len(msg)
        if df == 17 and msglen == 28:
            if pms.crc(msg) == 0:
                return True
        elif df in [20, 21] and msglen == 28:
            return True
        elif df in [4, 5, 11] and msglen == 14:
            return True

    def _debug_msg(self, msg):
        df = pms.df(msg)
        msglen = len(msg)
        if df == 17 and msglen == 28:
            print(msg, pms.icao(msg), pms.crc(msg))
        elif df in [20, 21] and msglen == 28:
            print(msg, pms.icao(msg))
        elif df in [4, 5, 11] and msglen == 14:
            print(msg, pms.icao(msg))
        else:
            # print("[*]", msg)
            pass

    def _read_callback(self, data, rtlsdr_obj):
        # scaling signal (imporatant)
        amp = np.absolute(data)
        amp_norm = np.interp(amp, (amp.min(), amp.max()), (0, 1))
        self.signal_buffer.extend(amp_norm.tolist())

        if len(self.signal_buffer) >= buffer_size:
            messages = self._process_buffer()
            self.handle_messages(messages)

    def handle_messages(self, messages):
        """re-implement this method to handle the messages"""
        for msg, t in messages:
            # print("%15.9f %s" % (t, msg))
            pass

    def stop(self, *args, **kwargs):
        self.sdr.cancel_read_async()

    def run(self, raw_pipe_in=None, stop_flag=None):
        self.raw_pipe_in = raw_pipe_in
        self.stop_flag = stop_flag
        self.sdr.read_samples_async(self._read_callback, read_size)
Esempio n. 4
0
class RadioReceiver:
    def __init__(self,
                 center_freq=446.1e6,
                 sample_rate=250e3,
                 freq_correction=0,
                 buffer_size=2048,
                 device_index=0):
        self._registeredQueueList = list()
        self._registeredQueueListLock = threading.Lock()
        self._sdr = RtlSdr(device_index)
        self._sdr.sample_rate = sample_rate
        self._sdr.center_freq = center_freq
        if self._sdr.freq_correction != freq_correction:
            self._sdr.freq_correction = freq_correction
        self._thread = threading.Thread(target=self._read_thread,
                                        args=(buffer_size, ))
        self._thread.start()

    @property
    def sample_rate(self):
        return self._sdr.sample_rate

    @sample_rate.setter
    def sample_rate(self, value):
        self._sdr.sample_rate = value

    @property
    def center_freq(self):
        return self._sdr.center_freq

    @center_freq.setter
    def center_freq(self, value):
        self._sdr.center_freq = value

    @property
    def freq_correction(self):
        return self._sdr.sample_rate

    @freq_correction.setter
    def freq_correction(self, value):
        if self._sdr.freq_correction != value:
            self._sdr.freq_correction = value

    def registerQueue(self, q: queue):
        with self._registeredQueueListLock:
            self._registeredQueueList.append(q)

    def unregisterQueue(self, q: queue):
        with self._registeredQueueListLock:
            if q in self._registeredQueueList:
                self._registeredQueueList.remove(q)

    @staticmethod
    def _read_samples_callback(buffer, self):
        with self._registeredQueueListLock:
            for q in self._registeredQueueList:
                if q.full():
                    q.get_nowait()
                q.put_nowait(buffer)

    def _read_thread(self, buffer_size):
        try:
            self._sdr.read_samples_async(RadioReceiver._read_samples_callback,
                                         buffer_size, self)
        except IOError:  #IOError is raised when read_async is canceled
            pass

    def close(self):
        self._sdr.cancel_read_async()
        self._thread.join()
        with self._registeredQueueListLock:
            for q in self._registeredQueueList:
                if q.full():
                    q.get_nowait()
                q.put_nowait(None)