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")
