def __init__(self, options, queue): gr.top_block.__init__(self) if options.filename is not None: self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename) self.rate = options.rate else: self.u = uhd.usrp_source(options.addr, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1) if options.subdev is not None: self.u.set_subdev_spec(options.subdev, 0) self.u.set_samp_rate(options.rate) self.rate = self.u.get_samp_rate() # Set the antenna if(options.antenna): self.u.set_antenna(options.antenna, 0) self.centerfreq = options.centerfreq print "Tuning to: %fMHz" % (self.centerfreq - options.error) if not(self.tune(options.centerfreq - options.error)): print "Failed to set initial frequency" if options.gain is None: #set to halfway g = self.u.get_gain_range() options.gain = (g.start()+g.stop()) / 2.0 print "Setting gain to %i" % options.gain self.u.set_gain(options.gain) self.u.set_bandwidth(options.bandwidth) print "Samples per second is %i" % self.rate self._syms_per_sec = 3600; options.samples_per_second = self.rate options.syms_per_sec = self._syms_per_sec options.gain_mu = 0.01 options.mu=0.5 options.omega_relative_limit = 0.3 options.syms_per_sec = self._syms_per_sec options.offset = options.centerfreq - options.freq print "Control channel offset: %f" % options.offset self.demod = fsk_demod(options) self.start_correlator = gr.correlate_access_code_tag_bb("10101100", 0, "smartnet_preamble") #should mark start of packet self.smartnet_deinterleave = smartnet.deinterleave() self.smartnet_crc = smartnet.crc(queue) if options.filename is None: self.connect(self.u, self.demod) else: self.connect(self.fs, self.demod) self.connect(self.demod, self.start_correlator, self.smartnet_deinterleave, self.smartnet_crc) #hook up the audio patch if options.audio: self.audiorate = 48000 self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, gr.firdes.WIN_HANN) self.prefilter_decim = int(self.rate / self.audiorate) #might have to use a rational resampler for audio print "Prefilter decimation: %i" % self.prefilter_decim self.audio_prefilter = gr.freq_xlating_fir_filter_ccf(self.prefilter_decim, #decimation self.audiotaps, #taps 0, #freq offset self.rate) #sampling rate #on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where #the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch. self.squelch = gr.pwr_squelch_cc(options.squelch, #squelch point alpha = 0.1, #wat ramp = 10, #wat gate = False) self.audiodemod = blks2.fm_demod_cf(self.rate/self.prefilter_decim, #rate 1, #audio decimation 4000, #deviation 3000, #audio passband 4000, #audio stopband 1, #gain 75e-6) #deemphasis constant #the filtering removes FSK data woobling from the subaudible channel (might be able to combine w/lpf above) self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, gr.firdes.WIN_HANN) self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps) self.audiogain = gr.multiply_const_ff(options.volume) self.audiosink = audio.sink (self.audiorate, "") # self.audiosink = gr.wavfile_sink("test.wav", 1, self.audiorate, 8) self.mute() if options.filename is None: self.connect(self.u, self.audio_prefilter) else: self.connect(self.fs, self.audio_prefilter) # self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audioresamp, self.audiosink) self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
def __init__(self): gr.top_block.__init__(self) self.samp_rate = samp_rate = 1000000 self.dump_freq = dump_freq = 2400490000 self._u = uhd.usrp_source( device_addr="%default", io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1) self._u.set_gain(0, 0) self._u.set_samp_rate(self.samp_rate) treq = uhd.tune_request(self.dump_freq, 0) tr = self._u.set_center_freq(treq) if tr == None: sys.stderr.write('Failed to set center frequency\n') raise SystemExit, 1 self.filter1 = gr.interp_fir_filter_ccf(1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76)) self.squelch = gr.pwr_squelch_cc(-100, 0.001, 0, True) self.demod = gr.quadrature_demod_cf(1) self.sync = digital.clock_recovery_mm_ff(2, 0.0076562, 0.5, 0.175, 0.005) self.slicer = digital.binary_slicer_fb() self.detect_seq = digital.correlate_access_code_bb("01010101010101010101010101010101", 1) self.dump = flysky.dumpsync() self.connect(self._u,self.filter1,self.squelch,self.demod,self.sync,self.slicer,self.detect_seq, self.dump)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1000000 self.dec_rate = dec_rate = 2 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(1000000) self.uhd_usrp_source_0.set_center_freq(2400490000, 0) self.uhd_usrp_source_0.set_gain(0, 0) self.low_pass_filter_0_0 = gr.interp_fir_filter_ccf( 1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0 = gr.fir_filter_fff( 1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76)) self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(1) self.gr_pwr_squelch_xx_0 = gr.pwr_squelch_cc(-100, 0.001, 0, True) self.flysky_dumpsync_0 = flysky.dumpsync() self.digital_correlate_access_code_bb_0_1 = digital.correlate_access_code_bb( "010101010101010101010101010101010101010001110101", 1) self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff( 2, 0.0076562, 0.5, 0.175, 0.005) self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb() ################################################## # Connections ################################################## self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0)) self.connect((self.gr_quadrature_demod_cf_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) self.connect((self.gr_pwr_squelch_xx_0, 0), (self.gr_quadrature_demod_cf_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0_0, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.gr_pwr_squelch_xx_0, 0)) self.connect((self.digital_binary_slicer_fb_0, 0), (self.digital_correlate_access_code_bb_0_1, 0)) self.connect((self.digital_correlate_access_code_bb_0_1, 0), (self.flysky_dumpsync_0, 0))
def __build_graph(self, source, capture_rate): # tell the scope the source rate self.spectrum.set_sample_rate(capture_rate) # channel filter self.channel_offset = 0.0 channel_decim = capture_rate // self.channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2 trans_centre = trans_width + (trans_width / 2) # discriminator tap doesn't do freq. xlation, FM demodulation, etc. if not self.baseband_input: coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf( channel_decim, coeffs, 0.0, capture_rate) self.set_channel_offset(0.0, 0, self.spectrum.win._units) # power squelch squelch_db = 0 self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True) self.set_squelch_threshold(squelch_db) # FM demodulator fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) # symbol filter symbol_decim = 1 #symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500) # boxcar coefficients for "integrate and dump" filter samples_per_symbol = channel_rate // self.symbol_rate symbol_coeffs = (1.0 / samples_per_symbol, ) * samples_per_symbol self.symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) # C4FM demodulator autotuneq = gr.msg_queue(2) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, self.symbol_rate) # for now no audio output sink = gr.null_sink(gr.sizeof_float) # connect it all up if self.baseband_input: self.rescaler = gr.multiply_const_ff(1) sinkx = gr.file_sink(gr.sizeof_float, "rx.dat") self.__connect([[ source, self.rescaler, self.symbol_filter, demod_fsk4, self.slicer, self.p25_decoder, sink ], [self.symbol_filter, self.signal_scope], [demod_fsk4, sinkx], [demod_fsk4, self.symbol_scope]]) self.connect_data_scope(not self.datascope_raw_input) else: self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) self.__connect([[ source, self.channel_filter, self.squelch, fm_demod, self.symbol_filter, demod_fsk4, self.slicer, self.p25_decoder, sink ], [source, self.spectrum], [self.symbol_filter, self.signal_scope], [demod_fsk4, self.symbol_scope]])
def __init__(self, options, rx_callback): gr.top_block.__init__(self) print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq)) # ---------------------------------------------------------------- self.data_rate = options.data_rate self.samples_per_symbol = 2 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) samp_rate=1e6 u = uhd.usrp_source( device_addr="serial=4c758445", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) u.set_subdev_spec("A:0", 0) u.set_samp_rate(samp_rate) u.set_center_freq(options.cordic_freq, 0) u.set_gain(options.gain, 0) #u = usrp.source_c (0, self.usrp_decim) #if options.rx_subdev_spec is None: # options.rx_subdev_spec = pick_subdevice(u) #u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) #subdev = usrp.selected_subdev(u, options.rx_subdev_spec) # print "Using RX d'board %s" % (subdev.side_and_name(),) # u.tune(0, subdev, options.cordic_freq) #u.set_pga(0, options.gain) #u.set_pga(1, options.gain) self.u = u self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect(self.u, self.squelch, self.packet_receiver)
def __init__(self, principal_gui, rx_callback, options): gr.hier_block2.__init__(self, "receive_path", gr.io_signature(0,0,0), # the 1,1 indicate the minimum, maximum stream in input gr.io_signature(0,0,0)) # the 0,0 indicate the minimum, maximum stream in output #local setup usrp source creat self.usrp source self._setup_usrp_source(options) options = copy.copy(options) # Make copy of the received options self._verbose = options.verbose self._bitrate = options.rate # The bit rate transmission self._samples_per_symbol= options.samples_per_symbol # samples/sample self._rx_callback = rx_callback #This callback is fired (declanche) when there's packet is available self.demodulator = bpsk_demodulator(principal_gui, options) #The demodulator used #Designe filter to get actual channel we want sw_decim = 1 #Create the low pass filter chan_coeffs = gr.firdes.low_pass (1.0, #gain sw_decim * self._samples_per_symbol, #sampling rate 1.0, #midpoint of trans band 0.5, #width of trans band gr.firdes.WIN_HAMMING) #filter type self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs) self.packet_receiver = ieee_pkt_receiver.ieee_pkt_receiver_868_915(self, gui = principal_gui, demodulator = self.demodulator, callback = rx_callback, sps = self._samples_per_symbol, symbol_rate = self._bitrate, threshold = -1) #Carrier Sensing Block (ecoute du canal) alpha = 0.001 # Carrier Sensing with dB, will have to adjust thresh = 30 #construct analyser of carrier (c'est un sink) self.probe = gr.probe_avg_mag_sqrd_c(thresh, alpha) #display information about the setup if self._verbose: self._print_verbage() #self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) #connect the input block to channel filter #connect the blocks with usrp, the self.usrp is created in _setup_usrp_source self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect(self._usrp, self.packet_receiver)
def __build_graph(self, source, capture_rate): # tell the scope the source rate self.spectrum.set_sample_rate(capture_rate) # channel filter self.channel_offset = 0.0 channel_decim = capture_rate // self.channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2 trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf( channel_decim, coeffs, 0.0, capture_rate) self.set_channel_offset(0.0, 0, self.spectrum.win._units) # power squelch squelch_db = 0 self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True) self.set_squelch_threshold(squelch_db) # FM demodulator fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) # symbol filter symbol_decim = 1 # symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500) # boxcar coefficients for "integrate and dump" filter samples_per_symbol = channel_rate // self.symbol_rate symbol_coeffs = (1.0 / samples_per_symbol, ) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, self.symbol_rate) # symbol slicer levels = [-2.0, 0.0, 2.0, 4.0] slicer = op25.fsk4_slicer_fb(levels) # ALSA output device (if not locked) try: sink = audio.sink(8000, "plughw:0,0", True) # ToDo: get actual device from prefs except Exception: sink = gr.null_sink(gr.sizeof_float) # connect it all up self.__connect([[ source, self.channel_filter, self.squelch, fm_demod, symbol_filter, demod_fsk4, slicer, self.p25_decoder, sink ], [source, self.spectrum], [symbol_filter, self.signal_scope], [demod_fsk4, self.symbol_scope]])
def __init__(self, options, rx_callback): """ @param options Optparse option field for command line arguments. @param rx_callback Callback function for the event when a packet is received. """ gr.flow_graph.__init__(self) print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq_rx)) # ---------------------------------------------------------------- self.data_rate = options.data_rate self.samples_per_symbol = 2 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_c (0, self.usrp_decim) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(u) u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(u, options.rx_subdev_spec) print "Using RX d'board %s" % (self.subdev.side_and_name(),) #self.subdev.select_rx_antenna('RX2') u.tune(0, self.subdev, options.cordic_freq_rx) u.set_pga(0, options.gain) u.set_pga(1, options.gain) self.u = u self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) #self.file_sink = gr.file_sink(gr.sizeof_gr_complex, "/dev/null") self.connect(self.u, self.squelch, self.packet_receiver) #self.connect(self.u, self.file_sink) self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __build_graph(self, source, capture_rate): # tell the scope the source rate self.spectrum.set_sample_rate(capture_rate) # channel filter self.channel_offset = 0.0 channel_decim = capture_rate // self.channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2; trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, 0.0, capture_rate) self.set_channel_offset(0.0) # power squelch squelch_db = 0 self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True) self.set_squelch_threshold(squelch_db) # FM demodulator fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) # symbol filter symbol_decim = 1 # symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500) # boxcar coefficients for "integrate and dump" filter samples_per_symbol = channel_rate // self.symbol_rate symbol_coeffs = (1.0/samples_per_symbol,)*samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, self.symbol_rate) # symbol slicer levels = [ -2.0, 0.0, 2.0, 4.0 ] slicer = op25.fsk4_slicer_fb(levels) # ALSA output device (if not locked) try: sink = audio.sink(8000, "plughw:0,0", True) # ToDo: get actual device from prefs except Exception: sink = gr.null_sink(gr.sizeof_float) # connect it all up self.__connect([[source, self.channel_filter, self.squelch, fm_demod, symbol_filter, demod_fsk4, slicer, self.p25_decoder, sink], [source, self.spectrum], [symbol_filter, self.signal_scope], [demod_fsk4, self.symbol_scope]])
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1000000 self.dec_rate = dec_rate = 2 ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="", stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1)) ) self.uhd_usrp_source_0.set_samp_rate(1000000) self.uhd_usrp_source_0.set_center_freq(2400490000, 0) self.uhd_usrp_source_0.set_gain(0, 0) self.low_pass_filter_0_0 = gr.interp_fir_filter_ccf( 1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76) ) self.low_pass_filter_0 = gr.fir_filter_fff( 1, firdes.low_pass(1, samp_rate, 500000, 10000, firdes.WIN_HAMMING, 6.76) ) self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(1) self.gr_pwr_squelch_xx_0 = gr.pwr_squelch_cc(-100, 0.001, 0, True) self.flysky_dumpsync_0 = flysky.dumpsync() self.digital_correlate_access_code_bb_0_1 = digital.correlate_access_code_bb( "010101010101010101010101010101010101010001110101", 1 ) self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff(2, 0.0076562, 0.5, 0.175, 0.005) self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb() ################################################## # Connections ################################################## self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0)) self.connect((self.gr_quadrature_demod_cf_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) self.connect((self.gr_pwr_squelch_xx_0, 0), (self.gr_quadrature_demod_cf_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0_0, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.gr_pwr_squelch_xx_0, 0)) self.connect((self.digital_binary_slicer_fb_0, 0), (self.digital_correlate_access_code_bb_0_1, 0)) self.connect((self.digital_correlate_access_code_bb_0_1, 0), (self.flysky_dumpsync_0, 0))
def __init__(self, options, rx_callback): gr.top_block.__init__(self) print "cordic_freq = %s" % (eng_notation.num_to_str( options.cordic_freq)) # ---------------------------------------------------------------- self.data_rate = options.data_rate self.samples_per_symbol = 2 self.usrp_decim = int(64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_c(0, self.usrp_decim) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(u) u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) subdev = usrp.selected_subdev(u, options.rx_subdev_spec) print "Using RX d'board %s" % (subdev.side_and_name(), ) u.tune(0, subdev, options.cordic_freq) u.set_pga(0, options.gain) u.set_pga(1, options.gain) self.u = u self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect(self.u, self.squelch, self.packet_receiver)
def __init__(self, rx_callback): gr.top_block.__init__(self) self.data_rate = 2000000 self.samples_per_symbol = 2 self.usrp_decim = int(64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) self.u = usrp.source_c(0, self.usrp_decim) self.picksubdev = pick_subdevice(self.u) self.u.set_mux(usrp.determine_rx_mux_value(self.u, self.picksubdev)) self.subdev = usrp.selected_subdev(self.u, pick_subdevice(self.u)) print "Using RX d'board %s" % (self.subdev.side_and_name(), ) #self.u.tune(0, self.subdev, 2475000000) #self.u.tune(0, self.subdev, 2480000000) self.u.tune(0, self.subdev, 2425000000) self.u.set_pga(0, 0) self.u.set_pga(1, 0) # receiver self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect(self.u, self.squelch, self.packet_receiver) # enable Auto Transmit/Receive switching self.set_auto_tr(True)
def __init__(self, options, rx_callback): gr.top_block.__init__(self) print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq)) # ---------------------------------------------------------------- self.data_rate = options.data_rate self.samples_per_symbol = 2 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_c (0, self.usrp_decim) if options.rx_subdev_spec is None: options.rx_subdev_spec = pick_subdevice(u) u.set_mux(usrp.determine_rx_mux_value(u, options.rx_subdev_spec)) subdev = usrp.selected_subdev(u, options.rx_subdev_spec) print "Using RX d'board %s" % (subdev.side_and_name(),) u.tune(0, subdev, options.cordic_freq) u.set_pga(0, options.gain) u.set_pga(1, options.gain) self.u = u #self.u = gr.file_source(gr.sizeof_gr_complex, 'rx_test.dat') self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect(self.u, self.squelch, self.packet_receiver)
def __init__(self, rx_callback): gr.top_block.__init__(self) self.data_rate = 2000000 self.samples_per_symbol = 2 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) self.u = usrp.source_c (0, self.usrp_decim) self.picksubdev = pick_subdevice(self.u) self.u.set_mux(usrp.determine_rx_mux_value(self.u, self.picksubdev)) self.subdev = usrp.selected_subdev(self.u, pick_subdevice(self.u)) print "Using RX d'board %s" % (self.subdev.side_and_name(),) #self.u.tune(0, self.subdev, 2475000000) #self.u.tune(0, self.subdev, 2480000000) self.u.tune(0, self.subdev, 2425000000) self.u.set_pga(0, 0) self.u.set_pga(1, 0) # receiver self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect(self.u, self.squelch, self.packet_receiver) # enable Auto Transmit/Receive switching self.set_auto_tr(True)
def __build_graph(self, source, capture_rate): # tell the scope the source rate self.spectrum.set_sample_rate(capture_rate) # channel filter self.channel_offset = 0.0 channel_decim = capture_rate // self.channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2; trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, -9500.0, capture_rate) self.set_channel_offset(0.0, 0, self.spectrum.win._units) # power squelch squelch_db = -60 self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True) self.set_squelch_threshold(squelch_db) # FM demodulator fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) # symbol filter symbol_decim = 1 #symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500) # boxcar coefficients for "integrate and dump" filter samples_per_symbol = channel_rate // self.symbol_rate symbol_coeffs = (1.0/samples_per_symbol,)*samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, self.symbol_rate) reverser = gr.multiply_const_ff(-1.0) # for now no audio output sink = gr.null_sink(gr.sizeof_float) # connect it all up self.__connect([[source, self.channel_filter, self.squelch, fm_demod, symbol_filter, demod_fsk4, reverser, self.slicer, self.p25_decoder, sink], [source, self.spectrum], [symbol_filter, self.signal_scope], [demod_fsk4, self.symbol_scope]])
def __init__(self, interface, address, center_freq, offset_freq, decim, squelch, gain): gr.top_block.__init__(self) # setup USRP2 u = usrp2.source_32fc(interface, address) u.set_decim(decim) capture_rate = u.adc_rate() / decim u.set_center_freq(center_freq) if gain is None: g = u.gain_range() gain = float(g[0] + g[1]) / 2 u.set_gain(gain) # Setup receiver attributes channel_rate = 125000 symbol_rate = 4800 # channel filter self.channel_offset = offset_freq channel_decim = capture_rate // channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2; trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, self.channel_offset, capture_rate) self.connect(u, self.channel_filter) # power squelch power_squelch = gr.pwr_squelch_cc(squelch, 1e-3, 0, True) self.connect(self.channel_filter, power_squelch) # FM demodulator self.symbol_deviation = 600.0 fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) self.connect(power_squelch, fm_demod) # symbol filter symbol_decim = 1 samples_per_symbol = channel_rate // symbol_rate symbol_coeffs = (1.0/samples_per_symbol,) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) self.connect(fm_demod, symbol_filter) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, symbol_rate) self.connect(symbol_filter, demod_fsk4) # symbol slicer levels = [ -2.0, 0.0, 2.0, 4.0 ] slicer = op25.fsk4_slicer_fb(levels) self.connect(demod_fsk4, slicer) # frame decoder decoder = op25.decoder_bf() self.connect(slicer, decoder) # try to connect audio output device try: audio_sink = audio.sink(8000, "plughw:0,0", True) self.connect(decoder, audio_sink) except Exception: sink = gr.null_sink(gr.sizeof_float) self.connect(decoder, null);
def __init__(self, rx_callback_cc2420, rx_callback_cc1k): gr.flow_graph.__init__(self) cc2420_cordic_freq = 2475000000 cc2420_data_rate = 2000000 cc1k_cordic_freq = 434845200 cc1k_data_rate = 38400 cc1k_sps = 8 payload_size = 128 print "cc2420_cordic_freq = %s" % ( eng_notation.num_to_str(cc2420_cordic_freq)) print "cc1k_cordic_freq = %s" % ( eng_notation.num_to_str(cc1k_cordic_freq)) # ---------------------------------------------------------------- self.data_rate = cc2420_data_rate self.samples_per_symbol = 2 self.usrp_decim = int(64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_c(0, nchan=2) u.set_decim_rate(self.usrp_decim) self.subdev = (u.db[0][0], u.db[1][0]) print "Using RX d'board %s" % (self.subdev[0].side_and_name(), ) print "Using RX d'board %s" % (self.subdev[1].side_and_name(), ) u.set_mux(0x2301) width = 8 shift = 8 format = u.make_format(width, shift) r = u.set_format(format) #this is the cc2420 code u.tune(self.subdev[0]._which, self.subdev[0], cc2420_cordic_freq) u.tune(self.subdev[1]._which, self.subdev[1], cc1k_cordic_freq) u.set_pga(0, 0) u.set_pga(1, 0) self.u = u # deinterleave two channels from FPGA di = gr.deinterleave(gr.sizeof_gr_complex) # wire up the head of the chain self.connect(self.u, di) #self.u = gr.file_source(gr.sizeof_gr_complex, 'rx_test.dat') # CC2420 receiver self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback_cc2420, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect((di, 0), self.squelch, self.packet_receiver) # CC1K receiver gain_mu = 0.002 * self.samples_per_symbol self.packet_receiver_cc1k = cc1k_sos_pkt.cc1k_demod_pkts( self, callback=rx_callback_cc1k, sps=cc1k_sps, symbol_rate=cc1k_data_rate, p_size=payload_size, threshold=-1) #self.squelch2 = gr.pwr_squelch_cc(50, 1, 0, True) keep = gr.keep_one_in_n(gr.sizeof_gr_complex, 13) #self.connect((di, 1), keep, self.squelch2, self.packet_receiver_cc1k) self.connect((di, 1), keep, self.packet_receiver_cc1k)
def __init__(self, subdev_spec, center_freq, offset_freq, decim, squelch, gain): gr.top_block.__init__(self) # configure USRP u = usrp.source_c() u.set_decim_rate(decim) capture_rate = u.adc_freq() / u.decim_rate() if subdev_spec is None: subdev_spec = usrp.pick_rx_subdevice(u) subdev = usrp.selected_subdev(u, subdev_spec) u.set_mux(usrp.determine_rx_mux_value(u, subdev_spec)) print "Using RX d'board %s" % (subdev.side_and_name(), ) if gain is None: g = subdev.gain_range() gain = float(g[0] + g[1]) / 2 subdev.set_gain(gain) u.tune(0, subdev, center_freq) # setup receiver attributes channel_rate = 125000 symbol_rate = 4800 # channel filter self.channel_offset = offset_freq channel_decim = capture_rate // channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2 trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf( channel_decim, coeffs, self.channel_offset, capture_rate) self.connect(u, self.channel_filter) # power squelch power_squelch = gr.pwr_squelch_cc(squelch, 1e-3, 0, True) self.connect(self.channel_filter, power_squelch) # FM demodulator self.symbol_deviation = 600.0 fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) self.connect(power_squelch, fm_demod) # symbol filter symbol_decim = 1 samples_per_symbol = channel_rate // symbol_rate symbol_coeffs = (1.0 / samples_per_symbol, ) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) self.connect(fm_demod, symbol_filter) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, symbol_rate) self.connect(symbol_filter, demod_fsk4) # symbol slicer levels = [-2.0, 0.0, 2.0, 4.0] slicer = op25.fsk4_slicer_fb(levels) self.connect(demod_fsk4, slicer) # frame decoder decoder = op25.decoder_bf() self.connect(slicer, decoder) # try to connect audio output device try: audio_sink = audio.sink(8000, "plughw:0,0", True) self.connect(decoder, audio_sink) except Exception: sink = gr.null_sink(gr.sizeof_float) self.connect(decoder, sink)
def __init__(self, options, queue): gr.top_block.__init__(self) if options.filename is not None: self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename) self.rate = 64000000 / options.decim # allow setting of recorded decimation in options else: self.u = usrp.source_c() self.u.set_mux(usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % self.subdev.side_and_name() self.u.set_decim_rate(options.decim) self.centerfreq = options.centerfreq print "Tuning to: %fMHz" % (self.centerfreq - options.error) if not(self.tune(options.centerfreq - options.error)): print "Failed to set initial frequency" if options.gain is None: #set to halfway g = self.subdev.gain_range() options.gain = (g[0]+g[1]) / 2.0 print "Setting gain to %i" % options.gain self.subdev.set_gain(options.gain) if self.subdev.name() == "DBS Rx": self.subdev.set_bw(options.bandwidth) #only for DBSRX print "Setting DBS RX bandwidth to %fMHz" % float(options.bandwidth / 1e6) self.rate = self.u.adc_rate() / options.decim print "Samples per second is %i" % self.rate self._syms_per_sec = 3600; options.samples_per_second = self.rate options.syms_per_sec = self._syms_per_sec options.gain_mu = 0.01 options.mu=0.5 options.omega_relative_limit = 0.3 options.syms_per_sec = self._syms_per_sec options.offset = options.centerfreq - options.freq print "Control channel offset: %f" % options.offset self.demod = fsk_demod(options) self.start_correlator = gr.correlate_access_code_bb("10101100",0) #should mark start of packet self.smartnet_sync = smartnet.sync() self.smartnet_deinterleave = smartnet.deinterleave() self.smartnet_parity = smartnet.parity() self.smartnet_crc = smartnet.crc() self.smartnet_packetize = smartnet.packetize() self.parse = smartnet.parse(queue) #packet-based. this simply posts lightly-formatted messages to the queue. # self.filesink = gr.file_sink(gr.sizeof_char*16, "smartnet_decoded.dat") #set a friggin filename in the options # self.paritysink = gr.file_sink(gr.sizeof_char, "smartnet_parity.dat") if options.filename is None: self.connect(self.u, self.demod) else: self.connect(self.fs, self.demod) self.connect(self.demod, self.start_correlator, self.smartnet_sync, self.smartnet_deinterleave, self.smartnet_parity, self.smartnet_crc, self.smartnet_packetize, self.parse) #hook up the audio patch if options.audio: self.audiorate = 48000 # self.audiodemoddecim = 4 self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, firdes.WIN_HANN) self.prefilter_decim = (self.rate / self.audiorate) #might have to use a rational resampler for audio print "Prefilter decimation: %i" % self.prefilter_decim self.audio_prefilter = gr.freq_xlating_fir_filter_ccc(self.prefilter_decim, #decimation self.audiotaps, #taps 0, #freq offset self.rate) #sampling rate #on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where #the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch. self.squelch = gr.pwr_squelch_cc(options.squelch, #squelch point alpha = 0.1, #wat ramp = 10, #wat gate = False) self.audiodemod = blks2.fm_demod_cf(self.rate/self.prefilter_decim, #rate 1, #audio decimation 4000, #deviation 3000, #audio passband 4000, #audio stopband 1, #gain 75e-6) #deemphasis constant #the point of the resampler is to bring data to the soundcard at a rate it supports, but it seems to sound fine without it, and it saves some CPU cycles not to have it #the audio rate is 48kHz because seemingly it's all my *&$# integrated sound card will support, otherwise it'd be like 8k or something reasonable #running a 48kHz audio rate isn't the end of the world -- with decim 18 and prefilter decim 74, the native rate is 48.048kHz. that's close enough to avoid the resampler. # self.gcd = self.euclid(self.audiorate, self.rate/self.prefilter_decim) # print "Resampling: decim %i, interp %i" % (self.rate/self.prefilter_decim/self.gcd, self.audiorate/self.gcd) # self.audioresamp = blks2.rational_resampler_fff(self.audiorate/self.gcd, self.rate/self.prefilter_decim/self.gcd)#, self.audiofilttaps) #the filtering removes FSK data woobling from the subaudible channel self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, firdes.WIN_HANN) self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps) self.audiogain = gr.multiply_const_ff(options.volume) # self.audiosink = audio.sink (self.audiorate, "") self.audiosink = gr.wavfile_sink("test.wav", 1, self.audiorate, 8) self.mute() if options.filename is None: self.connect(self.u, self.audio_prefilter) else: self.connect(self.fs, self.audio_prefilter) # self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audioresamp, self.audiosink) self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
def __init__(self, filename, offset_freq, squelch): gr.top_block.__init__(self) # open file and info f = open(filename + ".info", "r") info = cPickle.load(f) capture_rate = info["capture-rate"] f.close() file = gr.file_source(gr.sizeof_gr_complex, filename, True) throttle = gr.throttle(gr.sizeof_gr_complex, capture_rate) self.connect(file, throttle) # setup receiver attributes channel_rate = 125000 symbol_rate = 4800 # channel filter self.channel_offset = offset_freq channel_decim = capture_rate // channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2 trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf( channel_decim, coeffs, self.channel_offset, capture_rate) self.connect(throttle, self.channel_filter) # power squelch power_squelch = gr.pwr_squelch_cc(squelch, 1e-3, 0, True) self.connect(self.channel_filter, power_squelch) # FM demodulator self.symbol_deviation = 600.0 fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) self.connect(power_squelch, fm_demod) # symbol filter symbol_decim = 1 samples_per_symbol = channel_rate // symbol_rate symbol_coeffs = (1.0 / samples_per_symbol, ) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) self.connect(fm_demod, symbol_filter) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, symbol_rate) self.connect(symbol_filter, demod_fsk4) # symbol slicer levels = [-2.0, 0.0, 2.0, 4.0] slicer = op25.fsk4_slicer_fb(levels) self.connect(demod_fsk4, slicer) # frame decoder decoder = op25.decoder_bf() self.connect(slicer, decoder) # try to connect default output device try: audio_sink = audio.sink(8000, "plughw:0,0", True) self.connect(decoder, audio_sink) except Exception: sink = gr.null_sink(gr.sizeof_float) self.connect(decoder, sink)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.squelch = squelch = -20 self.samp_rate = samp_rate = 1e6 ################################################## # Blocks ################################################## _squelch_sizer = wx.BoxSizer(wx.VERTICAL) self._squelch_text_box = forms.text_box( parent=self.GetWin(), sizer=_squelch_sizer, value=self.squelch, callback=self.set_squelch, label='squelch', converter=forms.float_converter(), proportion=0, ) self._squelch_slider = forms.slider( parent=self.GetWin(), sizer=_squelch_sizer, value=self.squelch, callback=self.set_squelch, minimum=-99, maximum=0, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.Add(_squelch_sizer) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) self.Add(self.wxgui_fftsink2_0.win) self.low_pass_filter_0 = gr.fir_filter_ccf( 1, firdes.low_pass(1, samp_rate, 150e3, 100e3, firdes.WIN_HAMMING, 6.76)) self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex * 1, samp_rate) self.gr_sig_source_x_0 = gr.sig_source_c(samp_rate, gr.GR_COS_WAVE, 20e3, 1, 0) self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(1) self.gr_pwr_squelch_xx_0 = gr.pwr_squelch_cc(squelch, .1, 0, True) self.gr_multiply_xx_0 = gr.multiply_vcc(1) self.gr_file_source_0 = gr.file_source( gr.sizeof_gr_complex * 1, "/home/samurai/Desktop/SamuraiSTFU-Course-Files/GNURadio/Xyloc Proximity Card/sample/xyloc-clip-1Msps-rtl.cfile", True) self.gr_file_sink_0 = gr.file_sink(gr.sizeof_char * 1, "/tmp/bits") self.gr_file_sink_0.set_unbuffered(False) self.digital_correlate_access_code_bb_0 = digital.correlate_access_code_bb( "0011001101010101", 0) self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff( 8, .008, 0, .175, .005) self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb() ################################################## # Connections ################################################## self.connect((self.gr_throttle_0, 0), (self.gr_multiply_xx_0, 0)) self.connect((self.gr_file_source_0, 0), (self.gr_pwr_squelch_xx_0, 0)) self.connect((self.gr_pwr_squelch_xx_0, 0), (self.gr_throttle_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.gr_quadrature_demod_cf_0, 0)) self.connect((self.gr_quadrature_demod_cf_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0)) self.connect((self.digital_binary_slicer_fb_0, 0), (self.digital_correlate_access_code_bb_0, 0)) self.connect((self.digital_correlate_access_code_bb_0, 0), (self.gr_file_sink_0, 0)) self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 1)) self.connect((self.gr_multiply_xx_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.wxgui_fftsink2_0, 0))
def __init__(self, options, queue): gr.top_block.__init__(self) if options.filename is not None: self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename) self.rate = options.rate else: self.u = uhd.usrp_source(options.addr, io_type=uhd.io_type.COMPLEX_FLOAT32, num_channels=1) if options.subdev is not None: self.u.set_subdev_spec(options.subdev, 0) self.u.set_samp_rate(options.rate) self.rate = self.u.get_samp_rate() # Set the antenna if (options.antenna): self.u.set_antenna(options.antenna, 0) self.centerfreq = options.centerfreq print "Tuning to: %fMHz" % (self.centerfreq - options.error) if not (self.tune(options.centerfreq - options.error)): print "Failed to set initial frequency" if options.gain is None: #set to halfway g = self.u.get_gain_range() options.gain = (g.start() + g.stop()) / 2.0 print "Setting gain to %i" % options.gain self.u.set_gain(options.gain) self.u.set_bandwidth(options.bandwidth) print "Samples per second is %i" % self.rate self._syms_per_sec = 3600 options.samples_per_second = self.rate options.syms_per_sec = self._syms_per_sec options.gain_mu = 0.01 options.mu = 0.5 options.omega_relative_limit = 0.3 options.syms_per_sec = self._syms_per_sec options.offset = options.centerfreq - options.freq print "Control channel offset: %f" % options.offset self.demod = fsk_demod(options) self.start_correlator = gr.correlate_access_code_tag_bb( "10101100", 0, "smartnet_preamble") #should mark start of packet self.smartnet_deinterleave = smartnet.deinterleave() self.smartnet_crc = smartnet.crc(queue) if options.filename is None: self.connect(self.u, self.demod) else: self.connect(self.fs, self.demod) self.connect(self.demod, self.start_correlator, self.smartnet_deinterleave, self.smartnet_crc) #hook up the audio patch if options.audio: self.audiorate = 48000 self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, gr.firdes.WIN_HANN) self.prefilter_decim = int( self.rate / self.audiorate ) #might have to use a rational resampler for audio print "Prefilter decimation: %i" % self.prefilter_decim self.audio_prefilter = gr.freq_xlating_fir_filter_ccf( self.prefilter_decim, #decimation self.audiotaps, #taps 0, #freq offset self.rate) #sampling rate #on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where #the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch. self.squelch = gr.pwr_squelch_cc( options.squelch, #squelch point alpha=0.1, #wat ramp=10, #wat gate=False) self.audiodemod = blks2.fm_demod_cf( self.rate / self.prefilter_decim, #rate 1, #audio decimation 4000, #deviation 3000, #audio passband 4000, #audio stopband 1, #gain 75e-6) #deemphasis constant #the filtering removes FSK data woobling from the subaudible channel (might be able to combine w/lpf above) self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, gr.firdes.WIN_HANN) self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps) self.audiogain = gr.multiply_const_ff(options.volume) self.audiosink = audio.sink(self.audiorate, "") # self.audiosink = gr.wavfile_sink("test.wav", 1, self.audiorate, 8) self.mute() if options.filename is None: self.connect(self.u, self.audio_prefilter) else: self.connect(self.fs, self.audio_prefilter) # self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audioresamp, self.audiosink) self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
def __init__(self, options, rx_callback): gr.top_block.__init__(self) u = uhd.usrp_source(device_addr="addr0=192.168.20.4", stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1))) self.usrp_decim = 5 self.sampling_rate = 100e6 / self.usrp_decim u.set_samp_rate(self.sampling_rate) # WiFi Channel 6 self.usrp_freq = 2.437e9 u.set_center_freq(self.usrp_freq) options.gain = 20 u.set_gain(options.gain) u.set_subdev_spec("A:0", 0) u.set_antenna("TX/RX", 0) self.samples_per_symbol = 2 self.filter_decim = 5 self.data_rate = int(self.sampling_rate / self.samples_per_symbol / self.filter_decim) print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "usrp2_gain = ", options.gain # ZigBee Channel 17 self.chan1_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[ options.channel1] self.chan1_num = options.channel1 self.chan1_offset = self.usrp_freq - self.chan1_freq print "Centering USRP2 at = ", self.usrp_freq print "Channel ", self.chan1_num, " freq = ", self.usrp_freq - self.chan1_offset # Creating a filter for channel selection chan_coeffs = gr.firdes.low_pass( 1.0, # filter gain self.sampling_rate, # sampling rate 2e6, # cutoff frequency 2e6, # bandwidth gr.firdes.WIN_HANN) # filter type #print "Length of chan_coeffs = ", len(chan_coeffs) #print chan_coeffs # Decimating channel filters self.ddc1 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan1_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.packet_receiver1 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan1_num, threshold=-1, log=options.log) self.u = u self.squelch = gr.pwr_squelch_cc(options.squelch, gate=True) self.connect(self.u, self.squelch) self.connect(self.squelch, self.ddc1, self.packet_receiver1) self.connect(self.ddc1, gr.file_sink(gr.sizeof_gr_complex, 'wifi-zigbee-ddc.dat'))
def __init__(self, options): gr.top_block.__init__(self) self.options = options (dev_rate, channel_rate, audio_rate, channel_pass, channel_stop, demod) = demod_params[options.modulation] DEV = uhd_src( options.args, # UHD device address options.spec, # device subdev spec options.antenna, # device antenna dev_rate, # device sample rate options.gain, # Receiver gain options.calibration) # Frequency offset DEV.tune(options.frequency) if_rate = DEV.rate() channel_decim = int(if_rate // channel_rate) audio_decim = int(channel_rate // audio_rate) CHAN_taps = optfir.low_pass( 1.0, # Filter gain if_rate, # Sample rate channel_pass, # One sided modulation bandwidth channel_stop, # One sided channel bandwidth 0.1, # Passband ripple 60) # Stopband attenuation CHAN = gr.freq_xlating_fir_filter_ccf( channel_decim, # Decimation rate CHAN_taps, # Filter taps 0.0, # Offset frequency if_rate) # Sample rate RFSQL = gr.pwr_squelch_cc( options.rf_squelch, # Power threshold 125.0 / channel_rate, # Time constant int(channel_rate / 20), # 50ms rise/fall False) # Zero, not gate output AGC = gr.agc_cc( 1.0 / channel_rate, # Time constant 1.0, # Reference power 1.0, # Initial gain 1.0) # Maximum gain DEMOD = demod(channel_rate, audio_decim) # From RF to audio #self.connect(DEV, CHAN, RFSQL, AGC, DEMOD) self.connect(DEV, CHAN, DEMOD) # Optionally add CTCSS and RSAMP if needed tail = DEMOD if options.ctcss != None and options.ctcss > 60.0: CTCSS = gr.ctcss_squelch_ff( audio_rate, # Sample rate options.ctcss) # Squelch tone self.connect(DEMOD, CTCSS) tail = CTCSS if options.output_rate != audio_rate: out_lcm = gru.lcm(audio_rate, options.output_rate) out_interp = int(out_lcm // audio_rate) out_decim = int(out_lcm // options.output_rate) RSAMP = blks2.rational_resampler_fff(out_interp, out_decim) self.connect(tail, RSAMP) tail = RSAMP # Send to audio output device AUDIO = audio.sink(int(options.output_rate), options.audio_output) self.connect(tail, AUDIO)
def __init__(self, talkgroup, options): gr.hier_block2.__init__( self, "fsk_demod", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(0, 0, gr.sizeof_char)) # Output signature #print "Starting log_receiver init()" self.audiorate = options.audiorate self.rate = options.rate self.talkgroup = talkgroup self.directory = options.directory if options.squelch is None: options.squelch = 28 if options.volume is None: options.volume = 3.0 self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, gr.firdes.WIN_HANN) self.prefilter_decim = int(self.rate / self.audiorate) #the audio prefilter is a channel selection filter. self.audio_prefilter = gr.freq_xlating_fir_filter_ccf( self.prefilter_decim, #decimation self.audiotaps, #taps 0, #freq offset int(self.rate)) #sampling rate #on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where #the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch. self.squelch = gr.pwr_squelch_cc( options.squelch, #squelch point alpha=0.1, #wat ramp=10, #wat gate=True ) #gated so that the audio recording doesn't contain blank spaces between transmissions self.audiodemod = blks2.fm_demod_cf( self.rate / self.prefilter_decim, #rate 1, #audio decimation 4000, #deviation 3000, #audio passband 4000, #audio stopband options.volume, #gain 75e-6) #deemphasis constant #the filtering removes FSK data woobling from the subaudible channel self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, gr.firdes.WIN_HANN) self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps) #self.audiogain = gr.multiply_const_ff(options.volume) #here we generate a random filename in the form /tmp/[random].wav, and then use it for the wavstamp block. this avoids collisions later on. remember to clean up these files when deallocating. self.tmpfilename = "/tmp/%s.wav" % ( "".join([ random.choice(string.letters + string.digits) for x in range(8) ]) ) #if this looks glaringly different, it's because i totally cribbed it from a blog. self.valve = grc_blks2.valve(gr.sizeof_float, bool(1)) #self.prefiltervalve = grc_blks2.valve(gr.sizeof_gr_complex, bool(1)) #open the logfile for appending self.timestampfilename = "%s/%i.txt" % (self.directory, self.talkgroup) self.timestampfile = open(self.timestampfilename, 'a') self.filename = "%s/%i.wav" % (self.directory, self.talkgroup) self.audiosink = smartnet.wavsink( self.filename, 1, self.audiorate, 8) #this version allows appending to existing files. # self.connect(self, self.audio_prefilter, self.squelch, self.audiodemod, self.valve, self.audiofilt, self.audiosink) self.connect(self, self.audio_prefilter, self.audiodemod, self.valve, self.audiofilt, self.audiosink) self.timestamp = 0.0 #print "Finishing logging receiver init()." self.mute() #start off muted.
def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] [input file]" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-c", "--channel", type="string", default='AA', help="two-letter channel code (default: AA)") parser.add_option("-a", "--automatic", action="store_true", default=False, help="automatically determine and transmit reponse") parser.add_option("-R", "--rx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Rx side A or B (default=A)") parser.add_option("-g", "--gain", type="eng_float", default=None, help="set USRP gain in dB (default is midpoint)") parser.add_option("-s", "--squelch", type="eng_float", default=20, help="set squelch in dB") (options, args) = parser.parse_args() inf_str = None decim = 64 #1M Samp/sec symbol_rate = 152.34e3 sample_rate = 64e6 / decim if len(args) != 0: inf_str = args[0] squelch = gr.pwr_squelch_cc(float(options.squelch), 0.1, 0, True) demod = gr.quadrature_demod_cf(1.0) #cr = gr.clock_recovery_mm_ff(6.5643, 0.00765625, 0, 0.175, 0.005) cr = gr.clock_recovery_mm_ff(sample_rate / symbol_rate, 0.00765625, 0, 0.175, 0.005) slicer = gr.binary_slicer_fb() corr = gr.correlate_access_code_bb(AC, 0) sink = clicker.sniffer() if inf_str is not None: print "Reading from: " + inf_str src = gr.file_source(gr.sizeof_gr_complex, inf_str, False) else: freqs = { 'AA': 917.0e6, 'AB': 913.0e6, 'AC': 914.0e6, 'AD': 915.0e6, 'BA': 916.0e6, 'BB': 919.0e6, 'BC': 920.0e6, 'BD': 921.0e6, 'CA': 922.0e6, 'CB': 923.0e6, 'CC': 907.0e6, 'CD': 908.0e6, 'DA': 905.5e6, 'DB': 909.0e6, 'DC': 911.0e6, 'DD': 910.0e6 } frequency = freqs[options.channel] print "Channel: " + options.channel + " (" + str( frequency / 1e6) + "MHz)" src = usrp.source_c(decim_rate=decim) subdev = usrp.selected_subdev(src, options.rx_subdev_spec) print "Using RX board %s" % (subdev.side_and_name()) r = src.tune(0, subdev, frequency) if not r: raise SystemExit, "Failed to tune USRP. Are you using a 900MHz board?" if options.gain is None: # if no gain was specified, use the mid-point in dB g = subdev.gain_range() options.gain = float(g[0] + g[1]) / 2 subdev.set_gain(options.gain) print "Gain: " + str(options.gain) + "dB" self.connect(src, squelch, demod, cr, slicer, corr, sink)
def __init__(self, options, rx_callback): gr.top_block.__init__(self) u = usrp2.source_32fc(options.interface, options.mac_addr) self.usrp_decim = 4 self.samples_per_symbol = 2 self.filter_decim = 5 self.resamp_interp = 4 self.resamp_decim = 5 self.data_rate = int(u.adc_rate() / self.samples_per_symbol / self.usrp_decim / self.filter_decim * self.resamp_interp / self.resamp_decim) self.sampling_rate = int(u.adc_rate() / self.usrp_decim) print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "usrp2_gain = ", options.gain print "Squelch filter = ", options.squelch self.chan1_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[ options.channel1] self.chan1_num = options.channel1 self.chan2_num = self.chan1_num + 1 self.chan3_num = self.chan2_num + 1 self.chan4_num = self.chan3_num + 1 self.chan5_num = self.chan4_num + 1 self.chan5_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[ self.chan5_num] self.usrp_freq = (self.chan1_freq + self.chan5_freq) / 2 self.chan1_offset = self.usrp_freq - self.chan1_freq self.chan2_offset = self.chan1_offset - 5000000 self.chan3_offset = self.chan2_offset - 5000000 self.chan4_offset = self.chan3_offset - 5000000 self.chan5_offset = self.chan4_offset - 5000000 print "Centering USRP2 at = ", self.usrp_freq print "Channel ", self.chan1_num, " freq = ", self.usrp_freq - self.chan1_offset print "Channel ", self.chan2_num, " freq = ", self.usrp_freq - self.chan2_offset print "Channel ", self.chan3_num, " freq = ", self.usrp_freq - self.chan3_offset print "Channel ", self.chan4_num, " freq = ", self.usrp_freq - self.chan4_offset print "Channel ", self.chan5_num, " freq = ", self.usrp_freq - self.chan5_offset u.set_center_freq(self.usrp_freq) u.set_decim(self.usrp_decim) u.set_gain(options.gain) # Creating a filter for channel selection chan_coeffs = gr.firdes.low_pass( 1.0, # filter gain self.sampling_rate, # sampling rate 2e6, # cutoff frequency 2e6, # bandwidth gr.firdes.WIN_HANN) # filter type print "Length of chan_coeffs = ", len(chan_coeffs) # Decimating channel filters self.ddc1 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan1_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.ddc2 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan2_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.ddc3 = gr.fir_filter_ccf(self.filter_decim, chan_coeffs) self.ddc4 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan4_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.ddc5 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan5_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.packet_receiver1 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan1_num, threshold=-1) self.packet_receiver2 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan2_num, threshold=-1) self.packet_receiver3 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan3_num, threshold=-1) self.packet_receiver4 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan4_num, threshold=-1) self.packet_receiver5 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan5_num, threshold=-1) self.resampler1 = blks2.rational_resampler_ccf(self.resamp_interp, self.resamp_decim) self.resampler2 = blks2.rational_resampler_ccf(self.resamp_interp, self.resamp_decim) self.resampler3 = blks2.rational_resampler_ccf(self.resamp_interp, self.resamp_decim) self.resampler4 = blks2.rational_resampler_ccf(self.resamp_interp, self.resamp_decim) self.resampler5 = blks2.rational_resampler_ccf(self.resamp_interp, self.resamp_decim) self.u = u self.squelch = gr.pwr_squelch_cc(options.squelch, gate=True) self.connect(self.u, self.squelch) self.connect(self.squelch, self.ddc1, self.resampler1, self.packet_receiver1) self.connect(self.squelch, self.ddc2, self.resampler2, self.packet_receiver2) self.connect(self.squelch, self.ddc3, self.resampler3, self.packet_receiver3) self.connect(self.squelch, self.ddc4, self.resampler4, self.packet_receiver4) self.connect(self.squelch, self.ddc5, self.resampler5, self.packet_receiver5)
def __init__(self, options, queue): gr.top_block.__init__(self) if options.filename is not None: self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename) self.rate = 64000000 / options.decim # allow setting of recorded decimation in options else: self.u = usrp.source_c() self.u.set_mux( usrp.determine_rx_mux_value(self.u, options.rx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.rx_subdev_spec) print "Using RX d'board %s" % self.subdev.side_and_name() self.u.set_decim_rate(options.decim) self.centerfreq = options.centerfreq print "Tuning to: %fMHz" % (self.centerfreq - options.error) if not (self.tune(options.centerfreq - options.error)): print "Failed to set initial frequency" if options.gain is None: #set to halfway g = self.subdev.gain_range() options.gain = (g[0] + g[1]) / 2.0 print "Setting gain to %i" % options.gain self.subdev.set_gain(options.gain) if self.subdev.name() == "DBS Rx": self.subdev.set_bw(options.bandwidth) #only for DBSRX print "Setting DBS RX bandwidth to %fMHz" % float( options.bandwidth / 1e6) self.rate = self.u.adc_rate() / options.decim print "Samples per second is %i" % self.rate self._syms_per_sec = 3600 options.samples_per_second = self.rate options.syms_per_sec = self._syms_per_sec options.gain_mu = 0.01 options.mu = 0.5 options.omega_relative_limit = 0.3 options.syms_per_sec = self._syms_per_sec options.offset = options.centerfreq - options.freq print "Control channel offset: %f" % options.offset self.demod = fsk_demod(options) self.start_correlator = gr.correlate_access_code_bb( "10101100", 0) #should mark start of packet self.smartnet_sync = smartnet.sync() self.smartnet_deinterleave = smartnet.deinterleave() self.smartnet_parity = smartnet.parity() self.smartnet_crc = smartnet.crc() self.smartnet_packetize = smartnet.packetize() self.parse = smartnet.parse( queue ) #packet-based. this simply posts lightly-formatted messages to the queue. # self.filesink = gr.file_sink(gr.sizeof_char*16, "smartnet_decoded.dat") #set a friggin filename in the options # self.paritysink = gr.file_sink(gr.sizeof_char, "smartnet_parity.dat") if options.filename is None: self.connect(self.u, self.demod) else: self.connect(self.fs, self.demod) self.connect(self.demod, self.start_correlator, self.smartnet_sync, self.smartnet_deinterleave, self.smartnet_parity, self.smartnet_crc, self.smartnet_packetize, self.parse) #hook up the audio patch if options.audio: self.audiorate = 48000 # self.audiodemoddecim = 4 self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, firdes.WIN_HANN) self.prefilter_decim = ( self.rate / self.audiorate ) #might have to use a rational resampler for audio print "Prefilter decimation: %i" % self.prefilter_decim self.audio_prefilter = gr.freq_xlating_fir_filter_ccc( self.prefilter_decim, #decimation self.audiotaps, #taps 0, #freq offset self.rate) #sampling rate #on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where #the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch. self.squelch = gr.pwr_squelch_cc( options.squelch, #squelch point alpha=0.1, #wat ramp=10, #wat gate=False) self.audiodemod = blks2.fm_demod_cf( self.rate / self.prefilter_decim, #rate 1, #audio decimation 4000, #deviation 3000, #audio passband 4000, #audio stopband 1, #gain 75e-6) #deemphasis constant #the point of the resampler is to bring data to the soundcard at a rate it supports, but it seems to sound fine without it, and it saves some CPU cycles not to have it #the audio rate is 48kHz because seemingly it's all my *&$# integrated sound card will support, otherwise it'd be like 8k or something reasonable #running a 48kHz audio rate isn't the end of the world -- with decim 18 and prefilter decim 74, the native rate is 48.048kHz. that's close enough to avoid the resampler. # self.gcd = self.euclid(self.audiorate, self.rate/self.prefilter_decim) # print "Resampling: decim %i, interp %i" % (self.rate/self.prefilter_decim/self.gcd, self.audiorate/self.gcd) # self.audioresamp = blks2.rational_resampler_fff(self.audiorate/self.gcd, self.rate/self.prefilter_decim/self.gcd)#, self.audiofilttaps) #the filtering removes FSK data woobling from the subaudible channel self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, firdes.WIN_HANN) self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps) self.audiogain = gr.multiply_const_ff(options.volume) # self.audiosink = audio.sink (self.audiorate, "") self.audiosink = gr.wavfile_sink("test.wav", 1, self.audiorate, 8) self.mute() if options.filename is None: self.connect(self.u, self.audio_prefilter) else: self.connect(self.fs, self.audio_prefilter) # self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audioresamp, self.audiosink) self.connect(self.audio_prefilter, self.squelch, self.audiodemod, self.audiofilt, self.audiogain, self.audiosink)
def __init__(self, interface, address, center_freq, offset_freq, decim, squelch, gain): gr.top_block.__init__(self) # setup USRP2 u = usrp2.source_32fc(interface, address) u.set_decim(decim) capture_rate = u.adc_rate() / decim u.set_center_freq(center_freq) if gain is None: g = u.gain_range() gain = float(g[0] + g[1]) / 2 u.set_gain(gain) # Setup receiver attributes channel_rate = 125000 symbol_rate = 4800 # channel filter self.channel_offset = offset_freq channel_decim = capture_rate // channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2 trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf( channel_decim, coeffs, self.channel_offset, capture_rate) self.connect(u, self.channel_filter) # power squelch power_squelch = gr.pwr_squelch_cc(squelch, 1e-3, 0, True) self.connect(self.channel_filter, power_squelch) # FM demodulator self.symbol_deviation = 600.0 fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) self.connect(power_squelch, fm_demod) # symbol filter symbol_decim = 1 samples_per_symbol = channel_rate // symbol_rate symbol_coeffs = (1.0 / samples_per_symbol, ) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) self.connect(fm_demod, symbol_filter) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, symbol_rate) self.connect(symbol_filter, demod_fsk4) # symbol slicer levels = [-2.0, 0.0, 2.0, 4.0] slicer = op25.fsk4_slicer_fb(levels) self.connect(demod_fsk4, slicer) # frame decoder decoder = op25.decoder_bf() self.connect(slicer, decoder) # try to connect audio output device try: audio_sink = audio.sink(8000, "plughw:0,0", True) self.connect(decoder, audio_sink) except Exception: sink = gr.null_sink(gr.sizeof_float) self.connect(decoder, null)
def __init__(self, options, rx_callback): gr.top_block.__init__(self) u = uhd.usrp_source(device_addr="addr0=192.168.20.4",stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1))) self.usrp_decim = 5 self.sampling_rate = 100e6 / self.usrp_decim u.set_samp_rate(self.sampling_rate) # WiFi Channel 6 self.usrp_freq = 2.437e9 u.set_center_freq(self.usrp_freq) options.gain = 20 u.set_gain(options.gain) u.set_subdev_spec("A:0", 0) u.set_antenna("TX/RX", 0) self.samples_per_symbol = 2 self.filter_decim = 5 self.data_rate = int (self.sampling_rate / self.samples_per_symbol / self.filter_decim) print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "usrp2_gain = ", options.gain # ZigBee Channel 17 self.chan1_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[options.channel1] self.chan1_num = options.channel1 self.chan1_offset = self.usrp_freq - self.chan1_freq print "Centering USRP2 at = ", self.usrp_freq print "Channel ", self.chan1_num, " freq = ", self.usrp_freq - self.chan1_offset # Creating a filter for channel selection chan_coeffs = gr.firdes.low_pass( 1.0, # filter gain self.sampling_rate, # sampling rate 2e6, # cutoff frequency 2e6, # bandwidth gr.firdes.WIN_HANN) # filter type #print "Length of chan_coeffs = ", len(chan_coeffs) #print chan_coeffs # Decimating channel filters self.ddc1 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan1_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.packet_receiver1 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan1_num, threshold=-1, log=options.log) self.u = u self.squelch = gr.pwr_squelch_cc(options.squelch, gate=True) self.connect(self.u,self.squelch) self.connect(self.squelch, self.ddc1, self.packet_receiver1) self.connect(self.ddc1, gr.file_sink(gr.sizeof_gr_complex, 'wifi-zigbee-ddc.dat'))
def __init__(self, options): gr.top_block.__init__(self) self.options = options (usrp_decim, channel_decim, audio_decim, channel_pass, channel_stop, demod) = demod_params[options.modulation] USRP = usrp_src(options.rx_subdev_spec, # Daugherboard spec usrp_decim, # IF decimation ratio options.gain, # Receiver gain options.calibration) # Frequency offset USRP.tune(options.frequency) if_rate = USRP.rate() channel_rate = if_rate // channel_decim audio_rate = channel_rate // audio_decim CHAN_taps = optfir.low_pass(1.0, # Filter gain if_rate, # Sample rate channel_pass, # One sided modulation bandwidth channel_stop, # One sided channel bandwidth 0.1, # Passband ripple 60) # Stopband attenuation CHAN = gr.freq_xlating_fir_filter_ccf(channel_decim, # Decimation rate CHAN_taps, # Filter taps 0.0, # Offset frequency if_rate) # Sample rate RFSQL = gr.pwr_squelch_cc(options.rf_squelch, # Power threshold 125.0/channel_rate, # Time constant channel_rate/20, # 50ms rise/fall False) # Zero, not gate output AGC = gr.agc_cc(1.0/channel_rate, # Time constant 1.0, # Reference power 1.0, # Initial gain 1.0) # Maximum gain DEMOD = demod(channel_rate, audio_decim) # From RF to audio self.connect(USRP, CHAN, RFSQL, AGC, DEMOD) # Optionally add CTCSS and RSAMP if needed tail = DEMOD if options.ctcss != None and options.ctcss > 60.0: CTCSS = gr.ctcss_squelch_ff(audio_rate, # Sample rate options.ctcss) # Squelch tone self.connect(DEMOD, CTCSS) tail = CTCSS if options.output_rate != audio_rate: out_lcm = gru.lcm(audio_rate, options.output_rate) out_interp = int(out_lcm // audio_rate) out_decim = int(out_lcm // options.output_rate) RSAMP = blks2.rational_resampler_fff(out_interp, out_decim) self.connect(tail, RSAMP) tail = RSAMP # Send to default audio output AUDIO = audio.sink(options.output_rate, "") self.connect(tail, AUDIO)
def __init__(self, options, rx_callback): gr.top_block.__init__(self) u = usrp2.source_32fc(options.interface, options.mac_addr) self.usrp_decim = 4 self.samples_per_symbol = 2 self.filter_decim = 5 self.resamp_interp = 4 self.resamp_decim = 5 self.data_rate = int (u.adc_rate() / self.samples_per_symbol / self.usrp_decim / self.filter_decim * self.resamp_interp / self.resamp_decim) self.sampling_rate = int (u.adc_rate() / self.usrp_decim) print "data_rate = ", eng_notation.num_to_str(self.data_rate) print "samples_per_symbol = ", self.samples_per_symbol print "usrp_decim = ", self.usrp_decim print "usrp2_gain = ", options.gain print "Squelch filter = ", options.squelch self.chan1_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[options.channel1] self.chan1_num = options.channel1 self.chan2_num = self.chan1_num + 1 self.chan3_num = self.chan2_num + 1 self.chan4_num = self.chan3_num + 1 self.chan5_num = self.chan4_num + 1 self.chan5_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[self.chan5_num] self.usrp_freq = (self.chan1_freq + self.chan5_freq) / 2 self.chan1_offset = self.usrp_freq - self.chan1_freq self.chan2_offset = self.chan1_offset - 5000000 self.chan3_offset = self.chan2_offset - 5000000 self.chan4_offset = self.chan3_offset - 5000000 self.chan5_offset = self.chan4_offset - 5000000 print "Centering USRP2 at = ", self.usrp_freq print "Channel ", self.chan1_num, " freq = ", self.usrp_freq - self.chan1_offset print "Channel ", self.chan2_num, " freq = ", self.usrp_freq - self.chan2_offset print "Channel ", self.chan3_num, " freq = ", self.usrp_freq - self.chan3_offset print "Channel ", self.chan4_num, " freq = ", self.usrp_freq - self.chan4_offset print "Channel ", self.chan5_num, " freq = ", self.usrp_freq - self.chan5_offset u.set_center_freq(self.usrp_freq) u.set_decim(self.usrp_decim) u.set_gain(options.gain) # Creating a filter for channel selection chan_coeffs = gr.firdes.low_pass( 1.0, # filter gain self.sampling_rate, # sampling rate 2e6, # cutoff frequency 2e6, # bandwidth gr.firdes.WIN_HANN) # filter type print "Length of chan_coeffs = ", len(chan_coeffs) # Decimating channel filters self.ddc1 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan1_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.ddc2 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan2_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.ddc3 = gr.fir_filter_ccf(self.filter_decim, chan_coeffs) self.ddc4 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan4_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.ddc5 = gr.freq_xlating_fir_filter_ccf( self.filter_decim, # decimation rate chan_coeffs, # taps self.chan5_offset, # frequency translation amount self.sampling_rate) # input sampling rate self.packet_receiver1 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan1_num, threshold=-1) self.packet_receiver2 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan2_num, threshold=-1) self.packet_receiver3 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan3_num, threshold=-1) self.packet_receiver4 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan4_num, threshold=-1) self.packet_receiver5 = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, channel=self.chan5_num, threshold=-1) self.resampler1 = blks2.rational_resampler_ccf(self.resamp_interp,self.resamp_decim) self.resampler2 = blks2.rational_resampler_ccf(self.resamp_interp,self.resamp_decim) self.resampler3 = blks2.rational_resampler_ccf(self.resamp_interp,self.resamp_decim) self.resampler4 = blks2.rational_resampler_ccf(self.resamp_interp,self.resamp_decim) self.resampler5 = blks2.rational_resampler_ccf(self.resamp_interp,self.resamp_decim) self.u = u self.squelch = gr.pwr_squelch_cc(options.squelch, gate=True) self.connect(self.u,self.squelch) self.connect(self.squelch, self.ddc1, self.resampler1, self.packet_receiver1) self.connect(self.squelch, self.ddc2, self.resampler2, self.packet_receiver2) self.connect(self.squelch, self.ddc3, self.resampler3, self.packet_receiver3) self.connect(self.squelch, self.ddc4, self.resampler4, self.packet_receiver4) self.connect(self.squelch, self.ddc5, self.resampler5, self.packet_receiver5)
def __init__(self, filename, offset_freq, squelch): gr.top_block.__init__(self) # open file and info f = open(filename + ".info", "r") info = cPickle.load(f) capture_rate = info["capture-rate"] f.close() file = gr.file_source(gr.sizeof_gr_complex, filename, True) throttle = gr.throttle(gr.sizeof_gr_complex, capture_rate) self.connect(file, throttle) # setup receiver attributes channel_rate = 125000 symbol_rate = 4800 # channel filter self.channel_offset = offset_freq channel_decim = capture_rate // channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2; trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, self.channel_offset, capture_rate) self.connect(throttle, self.channel_filter) # power squelch power_squelch = gr.pwr_squelch_cc(squelch, 1e-3, 0, True) self.connect(self.channel_filter, power_squelch) # FM demodulator self.symbol_deviation = 600.0 fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) self.connect(power_squelch, fm_demod) # symbol filter symbol_decim = 1 samples_per_symbol = channel_rate // symbol_rate symbol_coeffs = (1.0/samples_per_symbol,) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) self.connect(fm_demod, symbol_filter) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, symbol_rate) self.connect(symbol_filter, demod_fsk4) # symbol slicer levels = [ -2.0, 0.0, 2.0, 4.0 ] slicer = op25.fsk4_slicer_fb(levels) self.connect(demod_fsk4, slicer) # frame decoder decoder = op25.decoder_bf() self.connect(slicer, decoder) # try to connect default output device try: audio_sink = audio.sink(8000, "plughw:0,0", True) self.connect(decoder, audio_sink) except Exception: sink = gr.null_sink(gr.sizeof_float) self.connect(decoder, sink)
def __init__(self, options): gr.top_block.__init__(self) self.options = options (dev_rate, channel_rate, audio_rate, channel_pass, channel_stop, demod) = demod_params[options.modulation] DEV = uhd_src(options.args, # UHD device address options.spec, # device subdev spec options.antenna, # device antenna dev_rate, # device sample rate options.gain, # Receiver gain options.calibration) # Frequency offset DEV.tune(options.frequency) if_rate = DEV.rate() channel_decim = int(if_rate // channel_rate) audio_decim = int(channel_rate // audio_rate) CHAN_taps = optfir.low_pass(1.0, # Filter gain if_rate, # Sample rate channel_pass, # One sided modulation bandwidth channel_stop, # One sided channel bandwidth 0.1, # Passband ripple 60) # Stopband attenuation CHAN = gr.freq_xlating_fir_filter_ccf(channel_decim, # Decimation rate CHAN_taps, # Filter taps 0.0, # Offset frequency if_rate) # Sample rate RFSQL = gr.pwr_squelch_cc(options.rf_squelch, # Power threshold 125.0/channel_rate, # Time constant int(channel_rate/20), # 50ms rise/fall False) # Zero, not gate output AGC = gr.agc_cc(1.0/channel_rate, # Time constant 1.0, # Reference power 1.0, # Initial gain 1.0) # Maximum gain DEMOD = demod(channel_rate, audio_decim) # From RF to audio #self.connect(DEV, CHAN, RFSQL, AGC, DEMOD) self.connect(DEV, CHAN, DEMOD) # Optionally add CTCSS and RSAMP if needed tail = DEMOD if options.ctcss != None and options.ctcss > 60.0: CTCSS = gr.ctcss_squelch_ff(audio_rate, # Sample rate options.ctcss) # Squelch tone self.connect(DEMOD, CTCSS) tail = CTCSS if options.output_rate != audio_rate: out_lcm = gru.lcm(audio_rate, options.output_rate) out_interp = int(out_lcm // audio_rate) out_decim = int(out_lcm // options.output_rate) RSAMP = blks2.rational_resampler_fff(out_interp, out_decim) self.connect(tail, RSAMP) tail = RSAMP # Send to audio output device AUDIO = audio.sink(int(options.output_rate), options.audio_output) self.connect(tail, AUDIO) # Direct asynchronous notifications to callback function if self.options.show_async_msg: self.async_msgq = gr.msg_queue(0) self.async_src = uhd.amsg_source("", self.async_msgq) self.async_rcv = gru.msgq_runner(self.async_msgq, self.async_callback)
def __init__(self, rx_callback_cc2420, rx_callback_cc1k): gr.flow_graph.__init__(self) cc2420_cordic_freq = 2475000000 cc2420_data_rate = 2000000 cc1k_cordic_freq = 434845200 cc1k_data_rate = 38400 cc1k_sps = 8 payload_size = 128 print "cc2420_cordic_freq = %s" % (eng_notation.num_to_str (cc2420_cordic_freq)) print "cc1k_cordic_freq = %s" % (eng_notation.num_to_str (cc1k_cordic_freq)) # ---------------------------------------------------------------- self.data_rate = cc2420_data_rate self.samples_per_symbol = 2 self.usrp_decim = int (64e6 / self.samples_per_symbol / self.data_rate) self.fs = self.data_rate * self.samples_per_symbol payload_size = 128 # bytes print "usrp_decim = ", self.usrp_decim print "fs = ", eng_notation.num_to_str(self.fs) u = usrp.source_c (0, nchan=2) u.set_decim_rate(self.usrp_decim) self.subdev = (u.db[0][0], u.db[1][0]) print "Using RX d'board %s" % (self.subdev[0].side_and_name(),) print "Using RX d'board %s" % (self.subdev[1].side_and_name(),) u.set_mux(0x2301) width = 8 shift = 8 format = u.make_format(width, shift) r = u.set_format(format) #this is the cc2420 code u.tune(self.subdev[0]._which, self.subdev[0], cc2420_cordic_freq) u.tune(self.subdev[1]._which, self.subdev[1], cc1k_cordic_freq) u.set_pga(0, 0) u.set_pga(1, 0) self.u = u # deinterleave two channels from FPGA di = gr.deinterleave(gr.sizeof_gr_complex) # wire up the head of the chain self.connect(self.u, di) #self.u = gr.file_source(gr.sizeof_gr_complex, 'rx_test.dat') # CC2420 receiver self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback_cc2420, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.squelch = gr.pwr_squelch_cc(50, 1, 0, True) self.connect((di,0), self.squelch, self.packet_receiver) # CC1K receiver gain_mu = 0.002*self.samples_per_symbol self.packet_receiver_cc1k = cc1k_sos_pkt.cc1k_demod_pkts(self, callback=rx_callback_cc1k, sps=cc1k_sps, symbol_rate=cc1k_data_rate, p_size=payload_size, threshold=-1) #self.squelch2 = gr.pwr_squelch_cc(50, 1, 0, True) keep = gr.keep_one_in_n(gr.sizeof_gr_complex, 13) #self.connect((di, 1), keep, self.squelch2, self.packet_receiver_cc1k) self.connect((di, 1), keep, self.packet_receiver_cc1k)
def __init__(self, antenna="TX/RX", rx_gain=30, vor_samp_rate=250e3, com_freq_1=135.275e6, gain=21, vor_freq_1=115e6): grc_wxgui.top_block_gui.__init__(self, title="Simple Trx") ################################################## # Parameters ################################################## self.antenna = antenna self.rx_gain = rx_gain self.vor_samp_rate = vor_samp_rate self.com_freq_1 = com_freq_1 self.gain = gain self.vor_freq_1 = vor_freq_1 ################################################## # Variables ################################################## self.obs_decimation = obs_decimation = 25 self.ils_decimation = ils_decimation = 50 self.am_sample_rate = am_sample_rate = 12.5e3 self.vor_volume_slider = vor_volume_slider = 5 self.vor_ident = vor_ident = False self.vor_freq_entry_1 = vor_freq_entry_1 = vor_freq_1 self.vor_center_freq_0 = vor_center_freq_0 = (117.95e6 - 108.00e6) / 2 + 117.95e6 self.system_center_freq = system_center_freq = 133.9e6 self.squelch_slider = squelch_slider = -85 self.samp_rate = samp_rate = 250e3 self.rxgain = rxgain = 15 self.phase_correction = phase_correction = 5 self.obs_sample_rate = obs_sample_rate = am_sample_rate / obs_decimation self.ils_sample_rate = ils_sample_rate = am_sample_rate / ils_decimation self.gain_slider = gain_slider = gain self.correction_gain = correction_gain = 0.8 self.com_volume_slider = com_volume_slider = 1 self.com_freq_entry_1 = com_freq_entry_1 = com_freq_1 self.com_enable = com_enable = True self.audio_select = audio_select = 0 self.audio_sample_rate = audio_sample_rate = 48e3 self.am_decimation = am_decimation = 1 ################################################## # Blocks ################################################## _vor_volume_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._vor_volume_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_vor_volume_slider_sizer, value=self.vor_volume_slider, callback=self.set_vor_volume_slider, label='vor_volume_slider', converter=forms.float_converter(), proportion=0, ) self._vor_volume_slider_slider = forms.slider( parent=self.GetWin(), sizer=_vor_volume_slider_sizer, value=self.vor_volume_slider, callback=self.set_vor_volume_slider, minimum=0, maximum=10, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_vor_volume_slider_sizer, 1, 4, 1, 1) self._vor_ident_check_box = forms.check_box( parent=self.GetWin(), value=self.vor_ident, callback=self.set_vor_ident, label='vor_ident', true=1, false=0, ) self.GridAdd(self._vor_ident_check_box, 0, 3, 1, 1) self._vor_freq_entry_1_text_box = forms.text_box( parent=self.GetWin(), value=self.vor_freq_entry_1, callback=self.set_vor_freq_entry_1, label='vor_freq_entry_1', converter=forms.float_converter(), ) self.GridAdd(self._vor_freq_entry_1_text_box, 0, 1, 1, 1) self.notebook_0 = self.notebook_0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP) self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "RF Analyzer") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Channel FFT") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Demod Audio FFT") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Ref and Phase Scope") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Manipulated Ref and Phase") self.Add(self.notebook_0) _com_volume_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._com_volume_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_com_volume_slider_sizer, value=self.com_volume_slider, callback=self.set_com_volume_slider, label='com_volume_slider', converter=forms.float_converter(), proportion=0, ) self._com_volume_slider_slider = forms.slider( parent=self.GetWin(), sizer=_com_volume_slider_sizer, value=self.com_volume_slider, callback=self.set_com_volume_slider, minimum=0, maximum=10, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_com_volume_slider_sizer, 1, 5, 1, 1) self._com_freq_entry_1_text_box = forms.text_box( parent=self.GetWin(), value=self.com_freq_entry_1, callback=self.set_com_freq_entry_1, label='com_freq_entry_1', converter=forms.float_converter(), ) self.GridAdd(self._com_freq_entry_1_text_box, 0, 0, 1, 1) self._com_enable_check_box = forms.check_box( parent=self.GetWin(), value=self.com_enable, callback=self.set_com_enable, label='com_enable', true=1, false=0, ) self.GridAdd(self._com_enable_check_box, 2, 3, 1, 1) self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.notebook_0.GetPage(3).GetWin(), title="Scope Plot", sample_rate=12.5e3, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=2, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.notebook_0.GetPage(3).Add(self.wxgui_scopesink2_0.win) self.wxgui_numbersink2_0 = numbersink2.number_sink_f( self.GetWin(), unit="Units", minval=-200, maxval=200, factor=1.0, decimal_places=10, ref_level=0, sample_rate=25e3 / 2000, number_rate=15, average=True, avg_alpha=0.02, label="Number Plot", peak_hold=False, show_gauge=True, ) self.Add(self.wxgui_numbersink2_0.win) self.wxgui_fftsink2_0_1 = fftsink2.fft_sink_c( self.notebook_0.GetPage(0).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=25e3, fft_size=1024, fft_rate=5, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) self.notebook_0.GetPage(0).Add(self.wxgui_fftsink2_0_1.win) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.notebook_0.GetPage(1).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=12.5e3, fft_size=1024, fft_rate=5, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) self.notebook_0.GetPage(1).Add(self.wxgui_fftsink2_0.win) self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(2), ), ) self.uhd_usrp_source_0.set_clock_source("internal", 0) self.uhd_usrp_source_0.set_subdev_spec("A:0 A:0", 0) self.uhd_usrp_source_0.set_samp_rate(vor_samp_rate) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(com_freq_entry_1, rf_freq=system_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0.set_gain(rx_gain, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) self.uhd_usrp_source_0.set_center_freq( uhd.tune_request(vor_freq_entry_1, rf_freq=system_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1) self.uhd_usrp_source_0.set_gain(rx_gain, 1) self.uhd_usrp_source_0.set_antenna("RX2", 1) self.uhd_usrp_sink_0 = uhd.usrp_sink( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_samp_rate(250e3) self.uhd_usrp_sink_0.set_center_freq(com_freq_entry_1, 0) self.uhd_usrp_sink_0.set_gain(25, 0) self.uhd_usrp_sink_0.set_antenna("TX/RX", 0) _squelch_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._squelch_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_squelch_slider_sizer, value=self.squelch_slider, callback=self.set_squelch_slider, label='squelch_slider', converter=forms.float_converter(), proportion=0, ) self._squelch_slider_slider = forms.slider( parent=self.GetWin(), sizer=_squelch_slider_sizer, value=self.squelch_slider, callback=self.set_squelch_slider, minimum=-100, maximum=0, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_squelch_slider_sizer, 1, 0, 1, 1) self.squelch = gr.pwr_squelch_cc(squelch_slider, 0.01, 20, False) self.openavionics_joystick_interface_0 = openavionics.joystick_interface( ) self.openavionics_audio_ptt_0 = openavionics.audio_ptt() self.low_pass_filter_3_0 = filter.fir_filter_fff( 5, firdes.low_pass(1, 25e3, 200, 50, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_3 = filter.fir_filter_fff( 5, firdes.low_pass(1, 25e3, 200, 50, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_2 = filter.fir_filter_ccf( 1, firdes.low_pass(1, 25e3, 3e3, 500, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_1 = filter.interp_fir_filter_fff( 1, firdes.low_pass(1, 12.5e3, 3e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0_0 = filter.fir_filter_ccf( int(250e3 / 25e3), firdes.low_pass(1, vor_samp_rate, 11e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0 = filter.fir_filter_ccf( int(250e3 / 12.5e3), firdes.low_pass(1, vor_samp_rate, 10e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.gr_sig_source_x_0 = gr.sig_source_c(25e3, gr.GR_COS_WAVE, 9960, 1, 0) self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(1) self.gr_pwr_squelch_xx_0 = gr.pwr_squelch_ff(-50, 0.5, 1, False) self.gr_null_sink_0_0 = gr.null_sink(gr.sizeof_gr_complex * 1) self.gr_multiply_xx_0_0_1 = gr.multiply_vff(1) self.gr_multiply_xx_0_0_0_0 = gr.multiply_vcc(1) self.gr_multiply_xx_0 = gr.multiply_vcc(1) self.gr_float_to_complex_0_0_0 = gr.float_to_complex(1) self.gr_float_to_complex_0 = gr.float_to_complex(1) self.gr_agc2_xx_0_0 = gr.agc2_cc(1, 1, 0.75, 1.0, 0.0) self.gr_agc2_xx_0 = gr.agc2_cc(1, 1, 0.75, 1.0, 0.0) self.gr_add_xx_0_0_0 = gr.add_vff(1) _gain_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._gain_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_gain_slider_sizer, value=self.gain_slider, callback=self.set_gain_slider, label='gain_slider', converter=forms.float_converter(), proportion=0, ) self._gain_slider_slider = forms.slider( parent=self.GetWin(), sizer=_gain_slider_sizer, value=self.gain_slider, callback=self.set_gain_slider, minimum=0, maximum=30, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_gain_slider_sizer, 1, 1, 1, 1) self.fft_tone_to_angle_0 = fft_tone_to_angle( fft_bin=12, fft_size=2000, ) self.const_source_x_0_1 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 0.450) self.const_source_x_0_0_1 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 0.550) self.const_source_x_0_0_0_0 = gr.sig_source_c(0, gr.GR_CONST_WAVE, 0, 0, 0.450) self.blocks_null_sink_1 = blocks.null_sink(gr.sizeof_float * 1) self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float * 1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff( (180.0 / 3.1415, )) self.blocks_add_xx_0 = blocks.add_vff(1) self.blks2_rational_resampler_xxx_2_0 = blks2.rational_resampler_fff( interpolation=250, decimation=48, taps=None, fractional_bw=None, ) self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff( interpolation=480, decimation=125, taps=None, fractional_bw=None, ) self.blks2_am_demod_cf_0_0 = blks2.am_demod_cf( channel_rate=25e3, audio_decim=am_decimation, audio_pass=11.5e3, audio_stop=12.250e3, ) self.blks2_am_demod_cf_0 = blks2.am_demod_cf( channel_rate=am_sample_rate, audio_decim=am_decimation, audio_pass=3e3, audio_stop=4e3, ) self.band_pass_filter_0 = gr.fir_filter_fff( 2, firdes.band_pass(1, 25000, 980, 1150, 50, firdes.WIN_HAMMING, 6.76)) self.audio_sink_0 = audio.sink(int(audio_sample_rate), "", True) self._audio_select_chooser = forms.drop_down( parent=self.GetWin(), value=self.audio_select, callback=self.set_audio_select, label='audio_select', choices=[0, 1], labels=['AM Voice', 'VOR Subcarrier'], ) self.GridAdd(self._audio_select_chooser, 0, 2, 1, 1) self.analog_sig_source_x_0_0 = analog.sig_source_f( 48000, analog.GR_COS_WAVE, 1000, 1, 0) self.adsf_0 = blocks.multiply_const_vff( (com_enable * com_volume_slider, )) self.adsf = blocks.multiply_const_vff( (vor_ident * vor_volume_slider, )) ################################################## # Connections ################################################## self.connect((self.gr_float_to_complex_0, 0), (self.gr_multiply_xx_0, 0)) self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.audio_sink_0, 0)) self.connect((self.blks2_am_demod_cf_0, 0), (self.low_pass_filter_1, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.uhd_usrp_source_0, 1), (self.gr_null_sink_0_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.squelch, 0)) self.connect((self.squelch, 0), (self.gr_agc2_xx_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.gr_agc2_xx_0, 0), (self.blks2_am_demod_cf_0, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.wxgui_fftsink2_0_1, 0)) self.connect((self.gr_agc2_xx_0_0, 0), (self.blks2_am_demod_cf_0_0, 0)) self.connect((self.uhd_usrp_source_0, 1), (self.low_pass_filter_0_0, 0)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.gr_float_to_complex_0, 0)) self.connect((self.fft_tone_to_angle_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.wxgui_numbersink2_0, 0)) self.connect((self.fft_tone_to_angle_0, 1), (self.blocks_null_sink_0, 0)) self.connect((self.fft_tone_to_angle_0, 2), (self.blocks_null_sink_1, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.gr_agc2_xx_0_0, 0)) self.connect((self.gr_quadrature_demod_cf_0, 0), (self.low_pass_filter_3, 0)) self.connect((self.low_pass_filter_3, 0), (self.fft_tone_to_angle_0, 0)) self.connect((self.low_pass_filter_3_0, 0), (self.fft_tone_to_angle_0, 1)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.low_pass_filter_3_0, 0)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.gr_float_to_complex_0, 1)) self.connect((self.gr_multiply_xx_0, 0), (self.low_pass_filter_2, 0)) self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 1)) self.connect((self.low_pass_filter_2, 0), (self.gr_quadrature_demod_cf_0, 0)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.band_pass_filter_0, 0)) self.connect((self.adsf, 0), (self.blocks_add_xx_0, 1)) self.connect((self.blocks_add_xx_0, 0), (self.blks2_rational_resampler_xxx_1, 0)) self.connect((self.adsf, 0), (self.wxgui_scopesink2_0, 1)) self.connect((self.low_pass_filter_1, 0), (self.adsf_0, 0)) self.connect((self.adsf_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.adsf_0, 0), (self.wxgui_scopesink2_0, 0)) self.connect((self.band_pass_filter_0, 0), (self.gr_pwr_squelch_xx_0, 0)) self.connect((self.gr_pwr_squelch_xx_0, 0), (self.adsf, 0)) self.connect((self.const_source_x_0_0_0_0, 0), (self.gr_multiply_xx_0_0_0_0, 1)) self.connect((self.gr_float_to_complex_0_0_0, 0), (self.gr_multiply_xx_0_0_0_0, 0)) self.connect((self.gr_add_xx_0_0_0, 0), (self.gr_float_to_complex_0_0_0, 1)) self.connect((self.gr_add_xx_0_0_0, 0), (self.gr_float_to_complex_0_0_0, 0)) self.connect((self.const_source_x_0_0_1, 0), (self.gr_add_xx_0_0_0, 1)) self.connect((self.gr_multiply_xx_0_0_1, 0), (self.gr_add_xx_0_0_0, 0)) self.connect((self.const_source_x_0_1, 0), (self.gr_multiply_xx_0_0_1, 1)) self.connect((self.gr_multiply_xx_0_0_0_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.blks2_rational_resampler_xxx_2_0, 0), (self.openavionics_audio_ptt_0, 0)) self.connect((self.analog_sig_source_x_0_0, 0), (self.blks2_rational_resampler_xxx_2_0, 0)) self.connect((self.openavionics_audio_ptt_0, 0), (self.gr_multiply_xx_0_0_1, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.openavionics_joystick_interface_0, "out", self.openavionics_audio_ptt_0, "in2")
def __init__(self, talkgroup, options): gr.hier_block2.__init__(self, "fsk_demod", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(0, 0, gr.sizeof_char)) # Output signature #print "Starting log_receiver init()" self.audiorate = options.audiorate self.rate = options.rate self.talkgroup = talkgroup self.directory = options.directory if options.squelch is None: options.squelch = 28 if options.volume is None: options.volume = 3.0 self.audiotaps = gr.firdes.low_pass(1, self.rate, 8000, 2000, gr.firdes.WIN_HANN) self.prefilter_decim = int(self.rate / self.audiorate) #the audio prefilter is a channel selection filter. self.audio_prefilter = gr.freq_xlating_fir_filter_ccf(self.prefilter_decim, #decimation self.audiotaps, #taps 0, #freq offset int(self.rate)) #sampling rate #on a trunked network where you know you will have good signal, a carrier power squelch works well. real FM receviers use a noise squelch, where #the received audio is high-passed above the cutoff and then fed to a reverse squelch. If the power is then BELOW a threshold, open the squelch. self.squelch = gr.pwr_squelch_cc(options.squelch, #squelch point alpha = 0.1, #wat ramp = 10, #wat gate = True) #gated so that the audio recording doesn't contain blank spaces between transmissions self.audiodemod = blks2.fm_demod_cf(self.rate/self.prefilter_decim, #rate 1, #audio decimation 4000, #deviation 3000, #audio passband 4000, #audio stopband options.volume, #gain 75e-6) #deemphasis constant #the filtering removes FSK data woobling from the subaudible channel self.audiofilttaps = gr.firdes.high_pass(1, self.audiorate, 300, 50, gr.firdes.WIN_HANN) self.audiofilt = gr.fir_filter_fff(1, self.audiofilttaps) #self.audiogain = gr.multiply_const_ff(options.volume) #here we generate a random filename in the form /tmp/[random].wav, and then use it for the wavstamp block. this avoids collisions later on. remember to clean up these files when deallocating. self.tmpfilename = "/tmp/%s.wav" % ("".join([random.choice(string.letters+string.digits) for x in range(8)])) #if this looks glaringly different, it's because i totally cribbed it from a blog. self.valve = grc_blks2.valve(gr.sizeof_float, bool(1)) #self.prefiltervalve = grc_blks2.valve(gr.sizeof_gr_complex, bool(1)) #open the logfile for appending self.timestampfilename = "%s/%i.txt" % (self.directory, self.talkgroup) self.timestampfile = open(self.timestampfilename, 'a'); self.filename = "%s/%i.wav" % (self.directory, self.talkgroup) self.audiosink = smartnet.wavsink(self.filename, 1, self.audiorate, 8) #this version allows appending to existing files. # self.connect(self, self.audio_prefilter, self.squelch, self.audiodemod, self.valve, self.audiofilt, self.audiosink) self.connect(self, self.audio_prefilter, self.audiodemod, self.valve, self.audiofilt, self.audiosink) self.timestamp = 0.0 #print "Finishing logging receiver init()." self.mute() #start off muted.
def __init__(self, subdev_spec, center_freq, offset_freq, decim, squelch, gain): gr.top_block.__init__(self) # configure USRP u = usrp.source_c() u.set_decim_rate(decim) capture_rate = u.adc_freq() / u.decim_rate() if subdev_spec is None: subdev_spec = usrp.pick_rx_subdevice(u) subdev = usrp.selected_subdev(u, subdev_spec) u.set_mux(usrp.determine_rx_mux_value(u, subdev_spec)) print "Using RX d'board %s" % (subdev.side_and_name(),) if gain is None: g = subdev.gain_range() gain = float(g[0] + g[1]) / 2 subdev.set_gain(gain) u.tune(0, subdev, center_freq) # setup receiver attributes channel_rate = 125000 symbol_rate = 4800 # channel filter self.channel_offset = offset_freq channel_decim = capture_rate // channel_rate channel_rate = capture_rate // channel_decim trans_width = 12.5e3 / 2; trans_centre = trans_width + (trans_width / 2) coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre, trans_width, gr.firdes.WIN_HANN) self.channel_filter = gr.freq_xlating_fir_filter_ccf(channel_decim, coeffs, self.channel_offset, capture_rate) self.connect(u, self.channel_filter) # power squelch power_squelch = gr.pwr_squelch_cc(squelch, 1e-3, 0, True) self.connect(self.channel_filter, power_squelch) # FM demodulator self.symbol_deviation = 600.0 fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation) fm_demod = gr.quadrature_demod_cf(fm_demod_gain) self.connect(power_squelch, fm_demod) # symbol filter symbol_decim = 1 samples_per_symbol = channel_rate // symbol_rate symbol_coeffs = (1.0/samples_per_symbol,) * samples_per_symbol symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs) self.connect(fm_demod, symbol_filter) # C4FM demodulator autotuneq = gr.msg_queue(2) self.demod_watcher = demod_watcher(autotuneq, self.adjust_channel_offset) demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate, symbol_rate) self.connect(symbol_filter, demod_fsk4) # symbol slicer levels = [ -2.0, 0.0, 2.0, 4.0 ] slicer = op25.fsk4_slicer_fb(levels) self.connect(demod_fsk4, slicer) # frame decoder decoder = op25.decoder_bf() self.connect(slicer, decoder) # try to connect audio output device try: audio_sink = audio.sink(8000, "plughw:0,0", True) self.connect(decoder, audio_sink) except Exception: sink = gr.null_sink(gr.sizeof_float) self.connect(decoder, sink)
def __init__(self, antenna="TX/RX", rx_gain=30, vor_samp_rate=250e3, com_freq_1=135.275e6, gain=21, vor_freq_1=115e6): grc_wxgui.top_block_gui.__init__(self, title="Simple Trx") ################################################## # Parameters ################################################## self.antenna = antenna self.rx_gain = rx_gain self.vor_samp_rate = vor_samp_rate self.com_freq_1 = com_freq_1 self.gain = gain self.vor_freq_1 = vor_freq_1 ################################################## # Variables ################################################## self.obs_decimation = obs_decimation = 25 self.ils_decimation = ils_decimation = 50 self.am_sample_rate = am_sample_rate = 12.5e3 self.vor_volume_slider = vor_volume_slider = 5 self.vor_ident = vor_ident = False self.vor_freq_entry_1 = vor_freq_entry_1 = vor_freq_1 self.vor_center_freq_0 = vor_center_freq_0 = (117.95e6-108.00e6)/2+117.95e6 self.system_center_freq = system_center_freq = 133.9e6 self.squelch_slider = squelch_slider = -85 self.samp_rate = samp_rate = 250e3 self.rxgain = rxgain = 15 self.phase_correction = phase_correction = 5 self.obs_sample_rate = obs_sample_rate = am_sample_rate/obs_decimation self.ils_sample_rate = ils_sample_rate = am_sample_rate/ils_decimation self.gain_slider = gain_slider = gain self.correction_gain = correction_gain = 0.8 self.com_volume_slider = com_volume_slider = 1 self.com_freq_entry_1 = com_freq_entry_1 = com_freq_1 self.com_enable = com_enable = True self.audio_select = audio_select = 0 self.audio_sample_rate = audio_sample_rate = 48e3 self.am_decimation = am_decimation = 1 ################################################## # Blocks ################################################## _vor_volume_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._vor_volume_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_vor_volume_slider_sizer, value=self.vor_volume_slider, callback=self.set_vor_volume_slider, label='vor_volume_slider', converter=forms.float_converter(), proportion=0, ) self._vor_volume_slider_slider = forms.slider( parent=self.GetWin(), sizer=_vor_volume_slider_sizer, value=self.vor_volume_slider, callback=self.set_vor_volume_slider, minimum=0, maximum=10, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_vor_volume_slider_sizer, 1, 4, 1, 1) self._vor_ident_check_box = forms.check_box( parent=self.GetWin(), value=self.vor_ident, callback=self.set_vor_ident, label='vor_ident', true=1, false=0, ) self.GridAdd(self._vor_ident_check_box, 0, 3, 1, 1) self._vor_freq_entry_1_text_box = forms.text_box( parent=self.GetWin(), value=self.vor_freq_entry_1, callback=self.set_vor_freq_entry_1, label='vor_freq_entry_1', converter=forms.float_converter(), ) self.GridAdd(self._vor_freq_entry_1_text_box, 0, 1, 1, 1) self.notebook_0 = self.notebook_0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP) self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "RF Analyzer") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Channel FFT") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Demod Audio FFT") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Ref and Phase Scope") self.notebook_0.AddPage(grc_wxgui.Panel(self.notebook_0), "Manipulated Ref and Phase") self.Add(self.notebook_0) _com_volume_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._com_volume_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_com_volume_slider_sizer, value=self.com_volume_slider, callback=self.set_com_volume_slider, label='com_volume_slider', converter=forms.float_converter(), proportion=0, ) self._com_volume_slider_slider = forms.slider( parent=self.GetWin(), sizer=_com_volume_slider_sizer, value=self.com_volume_slider, callback=self.set_com_volume_slider, minimum=0, maximum=10, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_com_volume_slider_sizer, 1, 5, 1, 1) self._com_freq_entry_1_text_box = forms.text_box( parent=self.GetWin(), value=self.com_freq_entry_1, callback=self.set_com_freq_entry_1, label='com_freq_entry_1', converter=forms.float_converter(), ) self.GridAdd(self._com_freq_entry_1_text_box, 0, 0, 1, 1) self._com_enable_check_box = forms.check_box( parent=self.GetWin(), value=self.com_enable, callback=self.set_com_enable, label='com_enable', true=1, false=0, ) self.GridAdd(self._com_enable_check_box, 2, 3, 1, 1) self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.notebook_0.GetPage(3).GetWin(), title="Scope Plot", sample_rate=12.5e3, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=2, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.notebook_0.GetPage(3).Add(self.wxgui_scopesink2_0.win) self.wxgui_numbersink2_0 = numbersink2.number_sink_f( self.GetWin(), unit="Units", minval=-200, maxval=200, factor=1.0, decimal_places=10, ref_level=0, sample_rate=25e3/2000, number_rate=15, average=True, avg_alpha=0.02, label="Number Plot", peak_hold=False, show_gauge=True, ) self.Add(self.wxgui_numbersink2_0.win) self.wxgui_fftsink2_0_1 = fftsink2.fft_sink_c( self.notebook_0.GetPage(0).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=25e3, fft_size=1024, fft_rate=5, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) self.notebook_0.GetPage(0).Add(self.wxgui_fftsink2_0_1.win) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.notebook_0.GetPage(1).GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=12.5e3, fft_size=1024, fft_rate=5, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) self.notebook_0.GetPage(1).Add(self.wxgui_fftsink2_0.win) self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(2), ), ) self.uhd_usrp_source_0.set_clock_source("internal", 0) self.uhd_usrp_source_0.set_subdev_spec("A:0 A:0", 0) self.uhd_usrp_source_0.set_samp_rate(vor_samp_rate) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(com_freq_entry_1, rf_freq=system_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0.set_gain(rx_gain, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(vor_freq_entry_1, rf_freq=system_center_freq, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 1) self.uhd_usrp_source_0.set_gain(rx_gain, 1) self.uhd_usrp_source_0.set_antenna("RX2", 1) self.uhd_usrp_sink_0 = uhd.usrp_sink( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_samp_rate(250e3) self.uhd_usrp_sink_0.set_center_freq(com_freq_entry_1, 0) self.uhd_usrp_sink_0.set_gain(25, 0) self.uhd_usrp_sink_0.set_antenna("TX/RX", 0) _squelch_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._squelch_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_squelch_slider_sizer, value=self.squelch_slider, callback=self.set_squelch_slider, label='squelch_slider', converter=forms.float_converter(), proportion=0, ) self._squelch_slider_slider = forms.slider( parent=self.GetWin(), sizer=_squelch_slider_sizer, value=self.squelch_slider, callback=self.set_squelch_slider, minimum=-100, maximum=0, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_squelch_slider_sizer, 1, 0, 1, 1) self.squelch = gr.pwr_squelch_cc(squelch_slider, 0.01, 20, False) self.openavionics_joystick_interface_0 = openavionics.joystick_interface() self.openavionics_audio_ptt_0 = openavionics.audio_ptt() self.low_pass_filter_3_0 = filter.fir_filter_fff(5, firdes.low_pass( 1, 25e3, 200, 50, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_3 = filter.fir_filter_fff(5, firdes.low_pass( 1, 25e3, 200, 50, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_2 = filter.fir_filter_ccf(1, firdes.low_pass( 1, 25e3, 3e3, 500, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_1 = filter.interp_fir_filter_fff(1, firdes.low_pass( 1, 12.5e3, 3e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0_0 = filter.fir_filter_ccf(int(250e3/25e3), firdes.low_pass( 1, vor_samp_rate, 11e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0 = filter.fir_filter_ccf(int(250e3/12.5e3), firdes.low_pass( 1, vor_samp_rate, 10e3, 1e3, firdes.WIN_HAMMING, 6.76)) self.gr_sig_source_x_0 = gr.sig_source_c(25e3, gr.GR_COS_WAVE, 9960, 1, 0) self.gr_quadrature_demod_cf_0 = gr.quadrature_demod_cf(1) self.gr_pwr_squelch_xx_0 = gr.pwr_squelch_ff(-50, 0.5, 1, False) self.gr_null_sink_0_0 = gr.null_sink(gr.sizeof_gr_complex*1) self.gr_multiply_xx_0_0_1 = gr.multiply_vff(1) self.gr_multiply_xx_0_0_0_0 = gr.multiply_vcc(1) self.gr_multiply_xx_0 = gr.multiply_vcc(1) self.gr_float_to_complex_0_0_0 = gr.float_to_complex(1) self.gr_float_to_complex_0 = gr.float_to_complex(1) self.gr_agc2_xx_0_0 = gr.agc2_cc(1, 1, 0.75, 1.0, 0.0) self.gr_agc2_xx_0 = gr.agc2_cc(1, 1, 0.75, 1.0, 0.0) self.gr_add_xx_0_0_0 = gr.add_vff(1) _gain_slider_sizer = wx.BoxSizer(wx.VERTICAL) self._gain_slider_text_box = forms.text_box( parent=self.GetWin(), sizer=_gain_slider_sizer, value=self.gain_slider, callback=self.set_gain_slider, label='gain_slider', converter=forms.float_converter(), proportion=0, ) self._gain_slider_slider = forms.slider( parent=self.GetWin(), sizer=_gain_slider_sizer, value=self.gain_slider, callback=self.set_gain_slider, minimum=0, maximum=30, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.GridAdd(_gain_slider_sizer, 1, 1, 1, 1) self.fft_tone_to_angle_0 = fft_tone_to_angle( fft_bin=12, fft_size=2000, ) self.const_source_x_0_1 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 0.450) self.const_source_x_0_0_1 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 0.550) self.const_source_x_0_0_0_0 = gr.sig_source_c(0, gr.GR_CONST_WAVE, 0, 0, 0.450) self.blocks_null_sink_1 = blocks.null_sink(gr.sizeof_float*1) self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((180.0/3.1415, )) self.blocks_add_xx_0 = blocks.add_vff(1) self.blks2_rational_resampler_xxx_2_0 = blks2.rational_resampler_fff( interpolation=250, decimation=48, taps=None, fractional_bw=None, ) self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff( interpolation=480, decimation=125, taps=None, fractional_bw=None, ) self.blks2_am_demod_cf_0_0 = blks2.am_demod_cf( channel_rate=25e3, audio_decim=am_decimation, audio_pass=11.5e3, audio_stop=12.250e3, ) self.blks2_am_demod_cf_0 = blks2.am_demod_cf( channel_rate=am_sample_rate, audio_decim=am_decimation, audio_pass=3e3, audio_stop=4e3, ) self.band_pass_filter_0 = gr.fir_filter_fff(2, firdes.band_pass( 1, 25000, 980, 1150, 50, firdes.WIN_HAMMING, 6.76)) self.audio_sink_0 = audio.sink(int(audio_sample_rate), "", True) self._audio_select_chooser = forms.drop_down( parent=self.GetWin(), value=self.audio_select, callback=self.set_audio_select, label='audio_select', choices=[0, 1], labels=['AM Voice','VOR Subcarrier'], ) self.GridAdd(self._audio_select_chooser, 0, 2, 1, 1) self.analog_sig_source_x_0_0 = analog.sig_source_f(48000, analog.GR_COS_WAVE, 1000, 1, 0) self.adsf_0 = blocks.multiply_const_vff((com_enable*com_volume_slider, )) self.adsf = blocks.multiply_const_vff((vor_ident*vor_volume_slider, )) ################################################## # Connections ################################################## self.connect((self.gr_float_to_complex_0, 0), (self.gr_multiply_xx_0, 0)) self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.audio_sink_0, 0)) self.connect((self.blks2_am_demod_cf_0, 0), (self.low_pass_filter_1, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.uhd_usrp_source_0, 1), (self.gr_null_sink_0_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.squelch, 0)) self.connect((self.squelch, 0), (self.gr_agc2_xx_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.wxgui_fftsink2_0, 0)) self.connect((self.gr_agc2_xx_0, 0), (self.blks2_am_demod_cf_0, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.wxgui_fftsink2_0_1, 0)) self.connect((self.gr_agc2_xx_0_0, 0), (self.blks2_am_demod_cf_0_0, 0)) self.connect((self.uhd_usrp_source_0, 1), (self.low_pass_filter_0_0, 0)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.gr_float_to_complex_0, 0)) self.connect((self.fft_tone_to_angle_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.wxgui_numbersink2_0, 0)) self.connect((self.fft_tone_to_angle_0, 1), (self.blocks_null_sink_0, 0)) self.connect((self.fft_tone_to_angle_0, 2), (self.blocks_null_sink_1, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.gr_agc2_xx_0_0, 0)) self.connect((self.gr_quadrature_demod_cf_0, 0), (self.low_pass_filter_3, 0)) self.connect((self.low_pass_filter_3, 0), (self.fft_tone_to_angle_0, 0)) self.connect((self.low_pass_filter_3_0, 0), (self.fft_tone_to_angle_0, 1)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.low_pass_filter_3_0, 0)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.gr_float_to_complex_0, 1)) self.connect((self.gr_multiply_xx_0, 0), (self.low_pass_filter_2, 0)) self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 1)) self.connect((self.low_pass_filter_2, 0), (self.gr_quadrature_demod_cf_0, 0)) self.connect((self.blks2_am_demod_cf_0_0, 0), (self.band_pass_filter_0, 0)) self.connect((self.adsf, 0), (self.blocks_add_xx_0, 1)) self.connect((self.blocks_add_xx_0, 0), (self.blks2_rational_resampler_xxx_1, 0)) self.connect((self.adsf, 0), (self.wxgui_scopesink2_0, 1)) self.connect((self.low_pass_filter_1, 0), (self.adsf_0, 0)) self.connect((self.adsf_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.adsf_0, 0), (self.wxgui_scopesink2_0, 0)) self.connect((self.band_pass_filter_0, 0), (self.gr_pwr_squelch_xx_0, 0)) self.connect((self.gr_pwr_squelch_xx_0, 0), (self.adsf, 0)) self.connect((self.const_source_x_0_0_0_0, 0), (self.gr_multiply_xx_0_0_0_0, 1)) self.connect((self.gr_float_to_complex_0_0_0, 0), (self.gr_multiply_xx_0_0_0_0, 0)) self.connect((self.gr_add_xx_0_0_0, 0), (self.gr_float_to_complex_0_0_0, 1)) self.connect((self.gr_add_xx_0_0_0, 0), (self.gr_float_to_complex_0_0_0, 0)) self.connect((self.const_source_x_0_0_1, 0), (self.gr_add_xx_0_0_0, 1)) self.connect((self.gr_multiply_xx_0_0_1, 0), (self.gr_add_xx_0_0_0, 0)) self.connect((self.const_source_x_0_1, 0), (self.gr_multiply_xx_0_0_1, 1)) self.connect((self.gr_multiply_xx_0_0_0_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.blks2_rational_resampler_xxx_2_0, 0), (self.openavionics_audio_ptt_0, 0)) self.connect((self.analog_sig_source_x_0_0, 0), (self.blks2_rational_resampler_xxx_2_0, 0)) self.connect((self.openavionics_audio_ptt_0, 0), (self.gr_multiply_xx_0_0_1, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.openavionics_joystick_interface_0, "out", self.openavionics_audio_ptt_0, "in2")