def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.tx_u = usrp.sink_c(fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
self.tx_u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
print 'tx subdev not set'
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.tx_u)
self.tx_u.set_mux(
usrp.determine_tx_mux_value(self.tx_u, self._tx_subdev_spec))
self.tx_subdev = usrp.selected_subdev(self.tx_u, self._tx_subdev_spec)
# Set center frequency of USRP
ok = self.tx_u.tune(1, self.tx_subdev, self._tx_freq)
if not ok:
print "Failed to set Tx frequency to %s" % (
eng_notation.num_to_str(self._tx_freq), )
raise ValueError
# enable Auto Transmit/Receive switching
self.tx_subdev.set_auto_tr(True)
def configure_cc2420(self):
self.disconnect_all()
gain = 0
cordic_freq = 2415000000
self.normal_gain = 8000
dac_rate = self.u.dac_rate();
self._data_rate = 2000000
self._spb = 2
self._interp = int(128e6 / self._spb / self._data_rate)
self.fs = 128e6 / self._interp
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
self.u.set_mux(usrp.determine_tx_mux_value(self.u, (0, 0)))
self.subdev = usrp.selected_subdev(self.u, (0, 0))
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.u.tune(self.subdev._which, self.subdev, cordic_freq)
self.u.set_pga(0, gain)
self.u.set_pga(1, gain)
# transmitter
self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(self, spb=self._spb, msgq_limit=2)
self.gain = gr.multiply_const_cc (self.normal_gain)
self.connect(self.packet_transmitter, self.gain, self.u)
#self.filesink = gr.file_sink(gr.sizeof_gr_complex, 'rx_test.dat')
#self.connect(self.gain, self.filesink)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self):
gr.top_block.__init__(self)
self.frequency = 13.56e6
self.gain = 100
# for 4 MS/s, 32
#
self.usrp_interpol = 32
# USRP settings
self.u_tx = usrp.sink_c() #create the USRP sink for TX
#try and set the LF_RX for this
self.tx_subdev_spec = usrp.pick_subdev(self.u_tx, (usrp_dbid.LF_RX, usrp_dbid.LF_TX))
#set the interpolation rate to match the USRP's 128 MS/s
self.u_tx.set_interp_rate(self.usrp_interpol)
#Configure the MUX for the daughterboard
self.u_tx.set_mux(usrp.determine_tx_mux_value(self.u_tx, self.tx_subdev_spec))
#Tell it to use the LF_TX
self.subdev_tx = usrp.selected_subdev(self.u_tx, self.tx_subdev_spec)
#Make sure it worked
print "Using TX dboard %s" % (self.subdev_tx.side_and_name(),)
#Set gain.. duh
self.subdev_tx.set_gain(self.gain)
#Tune the center frequency
self.u_tx.tune(0, self.subdev_tx, self.frequency)
# self.src = gr.wavfile_source("RFID_command_52_4M_1610.wav", True)
self.src = gr.wavfile_source("wave52.wav", True)
self.conv = gr.float_to_complex()
self.amp = gr.multiply_const_cc(10.0 ** (self.gain / 20.0))
self.connect(self.src, self.conv, self.amp, self.u_tx)
def __init__(self, options, usrp_rate, usrp_interp, tari_rate):
gr.hier_block2.__init__(self, "downlink_usrp_sink",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, 0))
self.u = usrp.sink_c()
#setup daughter boards
#subdev_spec = usrp.pick_tx_subdevice(self.u)
subdev_spec = (1, 0)
self.subdev = usrp.selected_subdev(self.u, subdev_spec)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, subdev_spec))
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
#set interp rate
self.u.set_interp_rate(usrp_interp)
self.subdev.set_gain(self.subdev.gain_range()[2])
#setup frequency
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(
options.freq), eng_notation.num_to_str(
freq_range[0]), eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True)
self.connect(self, self.u)
def __init__(self, fg, subdev_spec, interp, spb, use_barker):
self.normal_gain = 28000
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate();
self._spb = spb
self._interp=int(interp)
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if subdev_spec is None:
subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, subdev_spec))
self.subdev = usrp.selected_subdev(self.u, subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
# transmitter
self.packet_transmitter = bbn_80211b_mod_pkts(fg, spb=spb,
alpha=0.5,
gain=self.normal_gain,
use_barker=use_barker)
fg.connect(self.packet_transmitter, self.u)
gr.hier_block.__init__(self, fg, None, None)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.tx_u = usrp.sink_c(fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
self.tx_u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
print 'tx subdev not set'
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.tx_u)
self.tx_u.set_mux(usrp.determine_tx_mux_value(self.tx_u, self._tx_subdev_spec))
self.tx_subdev = usrp.selected_subdev(self.tx_u, self._tx_subdev_spec)
# Set center frequency of USRP
ok = self.tx_u.tune(1, self.tx_subdev, self._tx_freq)
if not ok:
print "Failed to set Tx frequency to %s" % (eng_notation.num_to_str(self._tx_freq),)
raise ValueError
# enable Auto Transmit/Receive switching
self.tx_subdev.set_auto_tr(True)
def __init__(self,options,usrp_rate,usrp_interp,tari_rate):
gr.hier_block2.__init__(self,"downlink_usrp_sink",
gr.io_signature(1,1,gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
self.u = usrp.sink_c()
#setup daughter boards
#subdev_spec = usrp.pick_tx_subdevice(self.u)
subdev_spec = (1, 0)
self.subdev = usrp.selected_subdev(self.u,subdev_spec)
self.u.set_mux(usrp.determine_tx_mux_value(self.u,subdev_spec))
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
#set interp rate
self.u.set_interp_rate(usrp_interp)
self.subdev.set_gain(self.subdev.gain_range()[2])
#setup frequency
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(options.freq),
eng_notation.num_to_str(freq_range[0]),
eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True)
self.connect(self,self.u)
def __init__(self, options):
gr.flow_graph.__init__(self)
self.normal_gain = 8000
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate();
self._data_rate = 2000000
self._spb = 2
self._interp = int(128e6 / self._spb / self._data_rate)
self.fs = 128e6 / self._interp
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.u.tune(self.subdev._which, self.subdev, options.cordic_freq_tx)
self.u.set_pga(0, options.gain)
self.u.set_pga(1, options.gain)
# transmitter
self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(self, spb=self._spb, msgq_limit=2)
self.gain = gr.multiply_const_cc (self.normal_gain)
self.connect(self.packet_transmitter, self.gain, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.u = usrp.sink_c(fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, self._tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, self._tx_subdev_spec)
# Set center frequency of USRP
ok = self.set_freq(self._tx_freq)
if not ok:
print "Failed to set Tx frequency to %s" % (eng_notation.num_to_str(self._tx_freq),)
raise ValueError
# Set the USRP for maximum transmit gain
# (Note that on the RFX cards this is a nop.)
self.set_gain(self.subdev.gain_range()[1])
# enable Auto Transmit/Receive switching
self.set_auto_tr(True)
def __init__(self):
gr.top_block.__init__(self)
self.frequency = 13.56e6
self.gain = 100
self.usrp_interpol = 32
# USRP settings
self.u_tx = usrp.sink_c() #create the USRP sink for TX
#try and set the LF_RX for this
self.tx_subdev_spec = usrp.pick_subdev(self.u_tx, (usrp_dbid.LF_RX, usrp_dbid.LF_TX))
#set the interpolation rate to match the USRP's 128 MS/s
self.u_tx.set_interp_rate(self.usrp_interpol)
#Configure the MUX for the daughterboard
self.u_tx.set_mux(usrp.determine_tx_mux_value(self.u_tx, self.tx_subdev_spec))
#Tell it to use the LF_TX
self.subdev_tx = usrp.selected_subdev(self.u_tx, self.tx_subdev_spec)
#Make sure it worked
print "Using TX dboard %s" % (self.subdev_tx.side_and_name(),)
#Set gain.. duh
self.subdev_tx.set_gain(self.gain)
#Tune the center frequency
self.u_tx.tune(0, self.subdev_tx, self.frequency)
self.src = gr.wavfile_source("RFID_command_52_4M_1610.wav", False)
self.conv = gr.float_to_complex()
self.amp = gr.multiply_const_cc(10.0 ** (self.gain / 20.0))
self.connect(self.src, self.conv, self.amp, self.u_tx)
def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.u = usrp.sink_c(fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, self._tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, self._tx_subdev_spec)
# Set center frequency of USRP
ok = self.set_freq(self._tx_freq)
if not ok:
print "Failed to set Tx frequency to %s" % (
eng_notation.num_to_str(self._tx_freq), )
raise ValueError
# Set the USRP for maximum transmit gain
# (Note that on the RFX cards this is a nop.)
self.set_gain(self.subdev.gain_range()[1])
# enable Auto Transmit/Receive switching
self.set_auto_tr(True)
def __init__(self, options):
gr.flow_graph.__init__(self)
self.normal_gain = 8000
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate()
self._data_rate = 2000000
self._spb = 2
self._interp = int(128e6 / self._spb / self._data_rate)
self.fs = 128e6 / self._interp
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.u.tune(self.subdev._which, self.subdev, options.cordic_freq_tx)
self.u.set_pga(0, options.gain)
self.u.set_pga(1, options.gain)
# transmitter
self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(
self, spb=self._spb, msgq_limit=2)
self.gain = gr.multiply_const_cc(self.normal_gain)
self.connect(self.packet_transmitter, self.gain, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def configure_cc2420(self):
self.disconnect_all()
gain = 0
cordic_freq = 2415000000
self.normal_gain = 8000
dac_rate = self.u.dac_rate()
self._data_rate = 2000000
self._spb = 2
self._interp = int(128e6 / self._spb / self._data_rate)
self.fs = 128e6 / self._interp
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
self.u.set_mux(usrp.determine_tx_mux_value(self.u, (0, 0)))
self.subdev = usrp.selected_subdev(self.u, (0, 0))
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.u.tune(self.subdev._which, self.subdev, cordic_freq)
self.u.set_pga(0, gain)
self.u.set_pga(1, gain)
# transmitter
self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(
self, spb=self._spb, msgq_limit=2)
self.gain = gr.multiply_const_cc(self.normal_gain)
self.connect(self.packet_transmitter, self.gain, self.u)
#self.filesink = gr.file_sink(gr.sizeof_gr_complex, 'rx_test.dat')
#self.connect(self.gain, self.filesink)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self, subdev_spec, freq, subdev_gain, filename, delay):
gr.top_block.__init__(self)
# data sink and sink rate
u = usrp.sink_c()
# important vars (to be calculated from USRP when available
dac_rate = u.dac_rate()
usrp_rate = 320e3
usrp_interp = int(dac_rate // usrp_rate)
channel_rate = 32e3
interp_factor = int(usrp_rate // channel_rate)
# open the pcap source
pcap = op25.pcap_source_b(filename, delay)
# pcap = gr.glfsr_source_b(16)
# convert octets into dibits
bits_per_symbol = 2
unpack = gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
# modulator
c4fm = p25_mod_bf(output_rate=channel_rate)
# setup low pass filter + interpolator
low_pass = 2.88e3
interp_taps = gr.firdes.low_pass(1.0, channel_rate, low_pass,
low_pass * 0.1, gr.firdes.WIN_HANN)
interpolator = gr.interp_fir_filter_fff(int(interp_factor),
interp_taps)
# frequency modulator
max_dev = 12.5e3
k = 2 * math.pi * max_dev / usrp_rate
adjustment = 1.5 # adjust for proper c4fm deviation level
fm = gr.frequency_modulator_fc(k * adjustment)
# signal gain
gain = gr.multiply_const_cc(4000)
# configure USRP
if subdev_spec is None:
subdev_spec = usrp.pick_tx_subdevice(u)
u.set_mux(usrp.determine_tx_mux_value(u, subdev_spec))
self.db = usrp.selected_subdev(u, subdev_spec)
print "Using TX d'board %s" % (self.db.side_and_name(), )
u.set_interp_rate(usrp_interp)
if gain is None:
g = self.db.gain_range()
gain = float(g[0] + g[1]) / 2
self.db.set_gain(self.db.gain_range()[0])
u.tune(self.db.which(), self.db, freq)
self.db.set_enable(True)
self.connect(pcap, unpack, c4fm, interpolator, fm, gain, u)
def __init__(self, subdev_spec, audio_input):
gr.hier_block2.__init__(
self,
"transmit_path",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(0, 0, 0)) # Output signature
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate()
self.if_rate = 320e3 # 320 kS/s
self.usrp_interp = int(dac_rate // self.if_rate)
self.u.set_interp_rate(self.usrp_interp)
self.sw_interp = 10
self.audio_rate = self.if_rate // self.sw_interp # 32 kS/s
self.audio_gain = 10
self.normal_gain = 32000
self.audio = audio.source(int(self.audio_rate), audio_input)
self.audio_amp = gr.multiply_const_ff(self.audio_gain)
lpf = gr.firdes.low_pass(
1, # gain
self.audio_rate, # sampling rate
3800, # low pass cutoff freq
300, # width of trans. band
gr.firdes.WIN_HANN) # filter type
hpf = gr.firdes.high_pass(
1, # gain
self.audio_rate, # sampling rate
325, # low pass cutoff freq
50, # width of trans. band
gr.firdes.WIN_HANN) # filter type
audio_taps = convolve(array(lpf), array(hpf))
self.audio_filt = gr.fir_filter_fff(1, audio_taps)
self.pl = blks2.ctcss_gen_f(self.audio_rate, 123.0)
self.add_pl = gr.add_ff()
self.connect(self.pl, (self.add_pl, 1))
self.fmtx = blks2.nbfm_tx(self.audio_rate, self.if_rate)
self.amp = gr.multiply_const_cc(self.normal_gain)
# determine the daughterboard subdevice we're using
if subdev_spec is None:
subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, subdev_spec))
self.subdev = usrp.selected_subdev(self.u, subdev_spec)
print "TX using", self.subdev.name()
self.connect(self.audio, self.audio_amp, self.audio_filt,
(self.add_pl, 0), self.fmtx, self.amp, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
def __init__(self, subdev_spec, audio_input):
gr.hier_block2.__init__(
self, "transmit_path", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0) # Input signature
) # Output signature
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate()
self.if_rate = 320e3 # 320 kS/s
self.usrp_interp = int(dac_rate // self.if_rate)
self.u.set_interp_rate(self.usrp_interp)
self.sw_interp = 10
self.audio_rate = self.if_rate // self.sw_interp # 32 kS/s
self.audio_gain = 10
self.normal_gain = 32000
self.audio = audio.source(int(self.audio_rate), audio_input)
self.audio_amp = gr.multiply_const_ff(self.audio_gain)
lpf = gr.firdes.low_pass(
1, # gain
self.audio_rate, # sampling rate
3800, # low pass cutoff freq
300, # width of trans. band
gr.firdes.WIN_HANN,
) # filter type
hpf = gr.firdes.high_pass(
1, # gain
self.audio_rate, # sampling rate
325, # low pass cutoff freq
50, # width of trans. band
gr.firdes.WIN_HANN,
) # filter type
audio_taps = convolve(array(lpf), array(hpf))
self.audio_filt = gr.fir_filter_fff(1, audio_taps)
self.pl = blks2.ctcss_gen_f(self.audio_rate, 123.0)
self.add_pl = gr.add_ff()
self.connect(self.pl, (self.add_pl, 1))
self.fmtx = blks2.nbfm_tx(self.audio_rate, self.if_rate)
self.amp = gr.multiply_const_cc(self.normal_gain)
# determine the daughterboard subdevice we're using
if subdev_spec is None:
subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, subdev_spec))
self.subdev = usrp.selected_subdev(self.u, subdev_spec)
print "TX using", self.subdev.name()
self.connect(self.audio, self.audio_amp, self.audio_filt, (self.add_pl, 0), self.fmtx, self.amp, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
def __init__(self):
gr.flow_graph.__init__(self)
parser = OptionParser(option_class=eng_option)
parser.add_option(
"-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help=
"select USRP Tx side A or B (default=first one with a daughterboard)"
)
parser.add_option("-c",
"--cordic-freq",
type="eng_float",
default=434845200,
help="set Tx cordic frequency to FREQ",
metavar="FREQ")
(options, args) = parser.parse_args()
print "cordic_freq = %s" % (eng_notation.num_to_str(
options.cordic_freq))
self.normal_gain = 8000
self.u = usrp.sink_s()
dac_rate = self.u.dac_rate()
self._freq = 1000
self._spb = 256
self._interp = int(128e6 / self._spb / self._freq)
self.fs = 128e6 / self._interp
print "Interpolation:", self._interp
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.u.tune(self.subdev._which, self.subdev, options.cordic_freq)
self.sin = gr.sig_source_f(self.fs, gr.GR_SIN_WAVE, self._freq, 1, 0)
self.gain = gr.multiply_const_ff(self.normal_gain)
self.ftos = gr.float_to_short()
self.filesink = gr.file_sink(gr.sizeof_float, 'sin.dat')
self.connect(self.sin, self.gain)
self.connect(self.gain, self.ftos, self.u)
#self.connect(self.gain, self.filesink)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def _setup_usrp1(self):
self._u = usrp.sink_c (self._which,
fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
# determine the daughterboard subdevice we're using
if self._subdev_spec is None:
self._subdev_spec = usrp.pick_tx_subdevice(self._u)
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
self._u.set_mux(usrp.determine_tx_mux_value(self._u, self._subdev_spec))
self._dxc = self._subdev.which()
def __init__(self, subdev_spec, freq, subdev_gain, filename, delay):
gr.top_block.__init__ (self)
# data sink and sink rate
u = usrp.sink_c()
# important vars (to be calculated from USRP when available
dac_rate = u.dac_rate()
usrp_rate = 320e3
usrp_interp = int(dac_rate // usrp_rate)
channel_rate = 32e3
interp_factor = int(usrp_rate // channel_rate)
# open the pcap source
pcap = op25.pcap_source_b(filename, delay)
# pcap = gr.glfsr_source_b(16)
# convert octets into dibits
bits_per_symbol = 2
unpack = gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
# modulator
c4fm = p25_mod_bf(output_rate=channel_rate)
# setup low pass filter + interpolator
low_pass = 2.88e3
interp_taps = gr.firdes.low_pass(1.0, channel_rate, low_pass, low_pass * 0.1, gr.firdes.WIN_HANN)
interpolator = gr.interp_fir_filter_fff (int(interp_factor), interp_taps)
# frequency modulator
max_dev = 12.5e3
k = 2 * math.pi * max_dev / usrp_rate
adjustment = 1.5 # adjust for proper c4fm deviation level
fm = gr.frequency_modulator_fc(k * adjustment)
# signal gain
gain = gr.multiply_const_cc(4000)
# configure USRP
if subdev_spec is None:
subdev_spec = usrp.pick_tx_subdevice(u)
u.set_mux(usrp.determine_tx_mux_value(u, subdev_spec))
self.db = usrp.selected_subdev(u, subdev_spec)
print "Using TX d'board %s" % (self.db.side_and_name(),)
u.set_interp_rate(usrp_interp)
if gain is None:
g = self.db.gain_range()
gain = float(g[0] + g[1]) / 2
self.db.set_gain(self.db.gain_range()[0])
u.tune(self.db.which(), self.db, freq)
self.db.set_enable(True)
self.connect(pcap, unpack, c4fm, interpolator, fm, gain, u)
def _setup_usrp1(self):
self._u = usrp.sink_c(self._which,
fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
# determine the daughterboard subdevice we're using
if self._subdev_spec is None:
self._subdev_spec = usrp.pick_tx_subdevice(self._u)
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
self._u.set_mux(usrp.determine_tx_mux_value(self._u,
self._subdev_spec))
self._dxc = self._subdev.which()
def __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, usage="%prog: [options] input-filename")
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=(0, 0),
help="select USRP Tx side A or B [default=A]")
parser.add_option("-f", "--freq", type="eng_float", default=227.36e6,
help="set frequency to FREQ [default=%default]")
parser.add_option("-g", "--tx-gain", type="eng_float", default=None,
help="set transmit gain in dB (default is midpoint)")
parser.add_option('-v', '--verbose', action="store_true", default=False,
help="verbose output")
(options, args) = parser.parse_args ()
if len(args)!=1:
parser.print_help()
sys.exit(1)
else:
self.filename = args[0]
# if gr.enable_realtime_scheduling() != gr.RT_OK:
# print "-> failed to enable realtime scheduling"
interp = 64
self.dab_params = dab.parameters.dab_parameters(mode=1, sample_rate=2000000, verbose=options.verbose)
self.src = gr.file_source(gr.sizeof_char, self.filename)
self.trigsrc = gr.vector_source_b([1]+[0]*(self.dab_params.symbols_per_frame-1),True)
self.s2v = gr.stream_to_vector(gr.sizeof_char, 384)
self.mod = dab.ofdm_mod(self.dab_params, verbose=options.verbose)
self.sink = usrp.sink_c(interp_rate = interp)
self.sink.set_mux(usrp.determine_tx_mux_value(self.sink, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.sink, options.tx_subdev_spec)
self.sample_rate = self.sink.dac_rate()/interp
print "--> using sample rate: " + str(self.sample_rate)
self.connect(self.src, self.s2v, self.mod, self.sink)
self.connect(self.trigsrc, (self.mod,1))
# tune frequency
self.sink.tune(0, self.subdev, options.freq)
# set gain
if options.tx_gain is None:
# if no gain was specified, use the mid-point in dB
g = self.subdev.gain_range()
options.tx_gain = float(g[0]+g[1])/2
self.subdev.set_gain(options.tx_gain)
def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.u = usrp.sink_c(self._which,
fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
dac_rate = self.u.dac_rate();
# derive values of bitrate, samples_per_symbol, and interp from desired info
(self._bitrate, self._samples_per_symbol, self._interp) = \
pick_tx_bitrate(self._bitrate, self._modulator_class.bits_per_symbol(),
self._samples_per_symbol, self._interp, dac_rate)
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
print "MUX VALUES"
print usrp.determine_tx_mux_value(self.u, self._tx_subdev_spec)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, self._tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, self._tx_subdev_spec)
def _setup_usrp(self, which, interp, subdev_spec, freq):
self._usrp = usrp.sink_c(which=which, interp_rate=interp)
if subdev_spec is None:
subdev_spec = usrp.pick_tx_subdevice(self._usrp)
self._usrp.set_mux(usrp.determine_tx_mux_value(self._usrp, subdev_spec))
self._subdev = usrp.selected_subdev(self._usrp, subdev_spec)
tr = usrp.tune(self._usrp, self._subdev.which(), self._subdev, freq)
if not (tr):
print "Failed to tune to center frequency!"
else:
print "Center frequency:", n2s(freq)
gain = float(self._subdev.gain_range()[1]) # Max TX gain
self._subdev.set_gain(gain)
self._subdev.set_enable(True)
print "TX d'board:", self._subdev.side_and_name()
def _setup_usrp_sink(self):
self.u_snk = usrp.sink_c(which = self._usrp,
fusb_block_size = self._fusb_block_size,
fusb_nblocks = self._fusb_nblocks)
self.u_snk.set_verbose(self._verbose)
self.u_snk.set_interp_rate(int(self.u_snk.converter_rate() / self._sample_rate))
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u_snk)
self.u_snk.set_mux(usrp.determine_tx_mux_value(self.u_snk, self._tx_subdev_spec))
self.tx_subdev = usrp.selected_subdev(self.u_snk, self._tx_subdev_spec)
self.tx_subdev.set_auto_tr(True)
self.tx_subdev.set_gain(self.tx_subdev.gain_range()[1])
def setup_usrp(freq):
# Constants
interp = 128
decim = 64
# Make USRP instances to TX and RX
utx = usrp.sink_c(fpga_filename="local_rssi5.rbf")
urx = usrp.source_c(fpga_filename="local_rssi5.rbf")
# Set decim and interp rates
utx.set_interp_rate(interp)
urx.set_decim_rate(decim)
# Pick subdevice
subdev_spec_tx = usrp.pick_tx_subdevice(utx)
subdev_spec_rx = usrp.pick_rx_subdevice(urx)
# Set up mux
mux_tx = usrp.determine_tx_mux_value(utx, subdev_spec_tx)
mux_rx = usrp.determine_rx_mux_value(urx, subdev_spec_rx)
utx.set_mux(mux_tx)
urx.set_mux(mux_rx)
# pick d'board
subdev_tx = usrp.selected_subdev(utx, subdev_spec_tx)
subdev_rx = usrp.selected_subdev(urx, subdev_spec_rx)
print "Using TX d'board %s" %(subdev_tx.side_and_name())
print "Using RX d'board %s" %(subdev_rx.side_and_name())
# Gain
subdev_tx.set_gain((subdev_tx.gain_range()[0] + subdev_tx.gain_range()[1]) / 2)
subdev_rx.set_gain((subdev_rx.gain_range()[0] + subdev_rx.gain_range()[1]) / 2)
# Tune
if not utx.tune(subdev_tx._which, subdev_tx, freq):
DEBUG( "error tuning TX")
if not urx.tune(subdev_rx._which, subdev_rx, freq):
DEBUG( "error tuning RX")
# Power on
subdev_tx.set_enable(True)
subdev_rx.set_enable(True)
sys.stdout.flush()
return utx, urx
def configure_cc1k(self):
#self.disconnect_all()
cordic_freq = 434845200
data_rate = 38400
gain = 0
print "cordic_freq = %s" % (eng_notation.num_to_str(cordic_freq))
self.data_rate = data_rate
self.samples_per_symbol = 8
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 "fs = ", eng_notation.num_to_str(self.fs)
self.normal_gain = 8000
dac_rate = self.u.dac_rate()
self.interp = int(128e6 / self.samples_per_symbol / self.data_rate)
print "usrp interp = ", self.interp
self.fs = 128e6 / self.interp
self.u.set_interp_rate(self.interp)
# determine the daughterboard subdevice we're using
self.u.set_mux(usrp.determine_tx_mux_value(self.u, (1, 0)))
self.subdev = usrp.selected_subdev(self.u, (1, 0))
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.u.tune(self.subdev._which, self.subdev, cordic_freq)
self.u.set_pga(0, gain)
self.u.set_pga(1, gain)
# transmitter
self.packet_transmitter = cc1k_sos_pkt.cc1k_mod_pkts(
self, spb=self.samples_per_symbol, msgq_limit=2)
self.amp = gr.multiply_const_cc(self.normal_gain)
self.connect(self.packet_transmitter, self.amp, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def configure_cc1k(self):
#self.disconnect_all()
cordic_freq = 434845200
data_rate = 38400
gain=0
print "cordic_freq = %s" % (eng_notation.num_to_str (cordic_freq))
self.data_rate = data_rate
self.samples_per_symbol = 8
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 "fs = ", eng_notation.num_to_str(self.fs)
self.normal_gain = 8000
dac_rate = self.u.dac_rate();
self.interp = int(128e6 / self.samples_per_symbol / self.data_rate)
print "usrp interp = ", self.interp
self.fs = 128e6 / self.interp
self.u.set_interp_rate(self.interp)
# determine the daughterboard subdevice we're using
self.u.set_mux(usrp.determine_tx_mux_value(self.u, (1, 0)))
self.subdev = usrp.selected_subdev(self.u, (1, 0))
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.u.tune(self.subdev._which, self.subdev, cordic_freq)
self.u.set_pga(0, gain)
self.u.set_pga(1, gain)
# transmitter
self.packet_transmitter = cc1k_sos_pkt.cc1k_mod_pkts(self, spb=self.samples_per_symbol, msgq_limit=2)
self.amp = gr.multiply_const_cc (self.normal_gain)
self.connect(self.packet_transmitter, self.amp, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self):
gr.flow_graph.__init__(self)
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B (default=first one with a daughterboard)")
parser.add_option ("-c", "--cordic-freq", type="eng_float", default=434845200,
help="set Tx cordic frequency to FREQ", metavar="FREQ")
(options, args) = parser.parse_args ()
print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq))
self.normal_gain = 8000
self.u = usrp.sink_s()
dac_rate = self.u.dac_rate();
self._freq = 1000
self._spb = 256
self._interp = int(128e6 / self._spb / self._freq)
self.fs = 128e6 / self._interp
print "Interpolation:", self._interp
self.u.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.u.tune(self.subdev._which, self.subdev, options.cordic_freq)
self.sin = gr.sig_source_f(self.fs, gr.GR_SIN_WAVE, self._freq, 1, 0)
self.gain = gr.multiply_const_ff (self.normal_gain)
self.ftos = gr.float_to_short()
self.filesink = gr.file_sink(gr.sizeof_float, 'sin.dat')
self.connect(self.sin, self.gain)
self.connect(self.gain, self.ftos, self.u)
#self.connect(self.gain, self.filesink)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def _setup_usrp_sink(self, options):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
#self.u = usrp_options.create_usrp_sink(options)
self.rs_rate = options.rate # Store requested bit rate
if_rate = options.rate*options.sps
self._interp = int(_dac_rate/if_rate)
options.interp = self._interp
self.u = usrp.sink_c(which = options.which, interp_rate = options.interp)
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self._subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
tr = usrp.tune(self.u, self._subdev.which(), self._subdev, options.freq)
if not (tr):
print "Failed to tune to center frequency!"
else:
print "Center frequency:", n2s(options.freq)
gain = float(self._subdev.gain_range()[1]) # Max TX gain
self._subdev.set_gain(gain)
self._subdev.set_enable(True)
print "TX d'board:", self._subdev.side_and_name()
#initiate hardly the value of bits per symbol to 1
self.bits_per_symbol = 1
# (self._bitrate, self._samples_per_symbol, self._interp) = \
# pick_bitrate.pick_tx_bitrate(options.bitrate, self.bits_per_symbol,
# options.samples_per_symbol, options.interp,
# dac_rate, self.u.get_interp_rates())
if options.verbose:
print 'USRP Sink:', self.u
print "Interpolation Rate: ", self._interp
def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.u_snk = usrp.sink_c(fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
self.u_snk.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u_snk)
self.u_snk.set_mux(usrp.determine_tx_mux_value(self.u_snk, self._tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u_snk, self._tx_subdev_spec)
# Set the USRP for maximum transmit gain
# (Note that on the RFX cards this is a nop.)
self.set_gain(self.subdev.gain_range()[1])
# enable Auto Transmit/Receive switching
self.set_auto_tr(True)
def _setup_usrp_sink(self):
"""
Creates a USRP sink, determines the settings for best bitrate,
and attaches to the transmitter's subdevice.
"""
self.u_snk = usrp.sink_c(fusb_block_size=self._fusb_block_size,
fusb_nblocks=self._fusb_nblocks)
self.u_snk.set_interp_rate(self._interp)
# determine the daughterboard subdevice we're using
if self._tx_subdev_spec is None:
self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u_snk)
self.u_snk.set_mux(
usrp.determine_tx_mux_value(self.u_snk, self._tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u_snk, self._tx_subdev_spec)
# Set the USRP for maximum transmit gain
# (Note that on the RFX cards this is a nop.)
self.set_gain(self.subdev.gain_range()[1])
# enable Auto Transmit/Receive switching
self.set_auto_tr(True)
def __init__(self):
gr.hier_block2.__init__(self, "tx_path", gr.io_signature(0, 0, 0),
gr.io_signature(0, 0, 0))
self.frequency = 13.56e6
self.normal_gain = 100
self.k = 0
self.usrp_interpol = int(128 / (SAMPLERATE / 1e6))
print "[+] Using interpolation rate of", self.usrp_interpol
# USRP settings
self.u_tx = usrp.sink_c() #create the USRP sink for TX
#try and set the LF_RX for this
self.tx_subdev_spec = usrp.pick_subdev(
self.u_tx, (usrp_dbid.LF_RX, usrp_dbid.LF_TX))
#set the interpolation rate to match the USRP's 128 MS/s
self.u_tx.set_interp_rate(self.usrp_interpol)
#Configure the MUX for the daughterboard
self.u_tx.set_mux(
usrp.determine_tx_mux_value(self.u_tx, self.tx_subdev_spec))
#Tell it to use the LF_TX
self.subdev_tx = usrp.selected_subdev(self.u_tx, self.tx_subdev_spec)
#Make sure it worked
print "Using TX dboard %s" % (self.subdev_tx.side_and_name(), )
#Set gain.. duh
self.subdev_tx.set_gain(self.normal_gain)
#Tune the center frequency
self.u_tx.tune(0, self.subdev_tx, self.frequency)
self.src = gr.wavfile_source("wave52.wav", True)
self.conv = gr.float_to_complex()
self.amp = gr.multiply_const_cc(10.0**(self.normal_gain / 20.0))
self.connect(self.src, self.conv, self.amp, self.u_tx)
def __init__(self):
gr.hier_block2.__init__(self, "tx_path",
gr.io_signature(0, 0, 0),
gr.io_signature(0, 0, 0))
self.frequency = 13.56e6
self.normal_gain = 100
self.k = 0
self.usrp_interpol = int(128/(SAMPLERATE/1e6))
print "[+] Using interpolation rate of",self.usrp_interpol
# USRP settings
self.u_tx = usrp.sink_c() #create the USRP sink for TX
#try and set the LF_RX for this
self.tx_subdev_spec = usrp.pick_subdev(self.u_tx, (usrp_dbid.LF_RX, usrp_dbid.LF_TX))
#set the interpolation rate to match the USRP's 128 MS/s
self.u_tx.set_interp_rate(self.usrp_interpol)
#Configure the MUX for the daughterboard
self.u_tx.set_mux(usrp.determine_tx_mux_value(self.u_tx, self.tx_subdev_spec))
#Tell it to use the LF_TX
self.subdev_tx = usrp.selected_subdev(self.u_tx, self.tx_subdev_spec)
#Make sure it worked
print "Using TX dboard %s" % (self.subdev_tx.side_and_name(),)
#Set gain.. duh
self.subdev_tx.set_gain(self.normal_gain)
#Tune the center frequency
self.u_tx.tune(0, self.subdev_tx, self.frequency)
self.src = gr.wavfile_source("wave52.wav", True)
self.conv = gr.float_to_complex()
self.amp = gr.multiply_const_cc(10.0 ** (self.normal_gain / 20.0))
self.connect(self.src, self.conv, self.amp, self.u_tx)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B")
parser.add_option(
"-f",
"--freq",
type="eng_float",
default=107.2e6,
help="set Tx frequency to FREQ [required]",
metavar="FREQ",
)
parser.add_option("--wavfile", type="string", default=None, help="open .wav audio file FILE")
parser.add_option("--xml", type="string", default="rds_data.xml", help="open .xml RDS data FILE")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
usrp_interp = 500
self.u = usrp.sink_c(0, usrp_interp)
print "USRP Serial: ", self.u.serial_number()
usrp_rate = self.u.dac_rate() / usrp_interp # 256 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using d'board", self.subdev.side_and_name()
# set max Tx gain, tune frequency and enable transmitter
gain = self.subdev.gain_range()[1]
self.subdev.set_gain(gain)
print "Gain set to", gain
if self.u.tune(self.subdev.which(), self.subdev, options.freq):
print "Tuned to", options.freq / 1e6, "MHz"
else:
sys.exit(1)
self.subdev.set_enable(True)
# open wav file containing floats in the [-1, 1] range, repeat
if options.wavfile is None:
print "Please provide a wavfile to transmit! Exiting\n"
sys.exit(1)
self.src = gr.wavfile_source(options.wavfile, True)
nchans = self.src.channels()
sample_rate = self.src.sample_rate()
bits_per_sample = self.src.bits_per_sample()
print nchans, "channels,", sample_rate, "samples/sec,", bits_per_sample, "bits/sample"
# resample to usrp rate
self.resample_left = blks2.rational_resampler_fff(usrp_rate, sample_rate)
self.resample_right = blks2.rational_resampler_fff(usrp_rate, sample_rate)
self.connect((self.src, 0), self.resample_left)
self.connect((self.src, 1), self.resample_right)
# create L+R (mono) and L-R (stereo)
self.audio_lpr = gr.add_ff()
self.audio_lmr = gr.sub_ff()
self.connect(self.resample_left, (self.audio_lpr, 0))
self.connect(self.resample_left, (self.audio_lmr, 0))
self.connect(self.resample_right, (self.audio_lpr, 1))
self.connect(self.resample_right, (self.audio_lmr, 1))
# low-pass filter for L+R
audio_lpr_taps = gr.firdes.low_pass(
0.5, # gain
usrp_rate, # sampling rate
15e3, # passband cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.audio_lpr_filter = gr.fir_filter_fff(1, audio_lpr_taps)
self.connect(self.audio_lpr, self.audio_lpr_filter)
# create pilot tone at 19 kHz
self.pilot = gr.sig_source_f(
usrp_rate, gr.GR_SIN_WAVE, 19e3, 5e-2 # sampling rate # waveform # frequency
) # amplitude
# upconvert L-R to 38 kHz and band-pass
self.mix_stereo = gr.multiply_ff()
audio_lmr_taps = gr.firdes.band_pass(
80, # gain
usrp_rate, # sampling rate
38e3 - 15e3, # low cutoff
38e3 + 15e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.audio_lmr_filter = gr.fir_filter_fff(1, audio_lmr_taps)
self.connect(self.audio_lmr, (self.mix_stereo, 0))
self.connect(self.pilot, (self.mix_stereo, 1))
self.connect(self.pilot, (self.mix_stereo, 2))
self.connect(self.mix_stereo, self.audio_lmr_filter)
# create RDS bitstream
# diff-encode, manchester-emcode, NRZ
# enforce the 1187.5bps rate
# pulse shaping filter (matched with receiver)
# mix with 57kHz carrier (equivalent to BPSK)
self.rds_enc = rds.data_encoder("rds_data.xml")
self.diff_enc = gr.diff_encoder_bb(2)
self.manchester1 = gr.map_bb([1, 2])
self.manchester2 = gr.unpack_k_bits_bb(2)
self.nrz = gr.map_bb([-1, 1])
self.c2f = gr.char_to_float()
self.rate_enforcer = rds.rate_enforcer(usrp_rate)
pulse_shaping_taps = gr.firdes.low_pass(
1, # gain
usrp_rate, # sampling rate
1.5e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.pulse_shaping = gr.fir_filter_fff(1, pulse_shaping_taps)
self.bpsk_mod = gr.multiply_ff()
self.connect(self.rds_enc, self.diff_enc, self.manchester1, self.manchester2, self.nrz, self.c2f)
self.connect(self.c2f, (self.rate_enforcer, 0))
self.connect(self.pilot, (self.rate_enforcer, 1))
self.connect(self.rate_enforcer, (self.bpsk_mod, 0))
self.connect(self.pilot, (self.bpsk_mod, 1))
self.connect(self.pilot, (self.bpsk_mod, 2))
self.connect(self.pilot, (self.bpsk_mod, 3))
# RDS band-pass filter
rds_filter_taps = gr.firdes.band_pass(
50, # gain
usrp_rate, # sampling rate
57e3 - 3e3, # low cutoff
57e3 + 3e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.rds_filter = gr.fir_filter_fff(1, rds_filter_taps)
self.connect(self.bpsk_mod, self.rds_filter)
# mix L+R, pilot, L-R and RDS
self.mixer = gr.add_ff()
self.connect(self.audio_lpr_filter, (self.mixer, 0))
self.connect(self.pilot, (self.mixer, 1))
self.connect(self.audio_lmr_filter, (self.mixer, 2))
self.connect(self.rds_filter, (self.mixer, 3))
# fm modulation, gain & TX
max_dev = 75e3
k = 2 * math.pi * max_dev / usrp_rate # modulator sensitivity
self.modulator = gr.frequency_modulator_fc(k)
self.gain = gr.multiply_const_cc(5e3)
self.connect(self.mixer, self.modulator, self.gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
self.fft = fftsink2.fft_sink_f(
panel, title="Pre FM modulation", fft_size=512 * 4, sample_rate=usrp_rate, y_per_div=20, ref_level=-20
)
self.connect(self.mixer, self.fft)
vbox.Add(self.fft.win, 1, wx.EXPAND)
if 0:
self.scope = scopesink2.scope_sink_f(panel, title="RDS encoder output", sample_rate=usrp_rate)
self.connect(self.rds_enc, self.scope)
vbox.Add(self.scope.win, 1, wx.EXPAND)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
parser.add_option("-f",
"--freq",
type="eng_float",
default=107.2e6,
help="set Tx frequency to FREQ [required]",
metavar="FREQ")
parser.add_option("--wavfile",
type="string",
default=None,
help="open .wav audio file FILE")
parser.add_option("--xml",
type="string",
default="rds_data.xml",
help="open .xml RDS data FILE")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
usrp_interp = 500
self.u = usrp.sink_c(0, usrp_interp)
print "USRP Serial: ", self.u.serial_number()
usrp_rate = self.u.dac_rate() / usrp_interp # 256 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using d'board", self.subdev.side_and_name()
# set max Tx gain, tune frequency and enable transmitter
gain = self.subdev.gain_range()[1]
self.subdev.set_gain(gain)
print "Gain set to", gain
if self.u.tune(self.subdev.which(), self.subdev, options.freq):
print "Tuned to", options.freq / 1e6, "MHz"
else:
sys.exit(1)
self.subdev.set_enable(True)
# open wav file containing floats in the [-1, 1] range, repeat
if options.wavfile is None:
print "Please provide a wavfile to transmit! Exiting\n"
sys.exit(1)
self.src = gr.wavfile_source(options.wavfile, True)
nchans = self.src.channels()
sample_rate = self.src.sample_rate()
bits_per_sample = self.src.bits_per_sample()
print nchans, "channels,", sample_rate, "samples/sec,", \
bits_per_sample, "bits/sample"
# resample to usrp rate
self.resample_left = blks2.rational_resampler_fff(
usrp_rate, sample_rate)
self.resample_right = blks2.rational_resampler_fff(
usrp_rate, sample_rate)
self.connect((self.src, 0), self.resample_left)
self.connect((self.src, 1), self.resample_right)
# create L+R (mono) and L-R (stereo)
self.audio_lpr = gr.add_ff()
self.audio_lmr = gr.sub_ff()
self.connect(self.resample_left, (self.audio_lpr, 0))
self.connect(self.resample_left, (self.audio_lmr, 0))
self.connect(self.resample_right, (self.audio_lpr, 1))
self.connect(self.resample_right, (self.audio_lmr, 1))
# low-pass filter for L+R
audio_lpr_taps = gr.firdes.low_pass(
0.5, # gain
usrp_rate, # sampling rate
15e3, # passband cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.audio_lpr_filter = gr.fir_filter_fff(1, audio_lpr_taps)
self.connect(self.audio_lpr, self.audio_lpr_filter)
# create pilot tone at 19 kHz
self.pilot = gr.sig_source_f(
usrp_rate, # sampling rate
gr.GR_SIN_WAVE, # waveform
19e3, # frequency
5e-2) # amplitude
# upconvert L-R to 38 kHz and band-pass
self.mix_stereo = gr.multiply_ff()
audio_lmr_taps = gr.firdes.band_pass(
80, # gain
usrp_rate, # sampling rate
38e3 - 15e3, # low cutoff
38e3 + 15e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.audio_lmr_filter = gr.fir_filter_fff(1, audio_lmr_taps)
self.connect(self.audio_lmr, (self.mix_stereo, 0))
self.connect(self.pilot, (self.mix_stereo, 1))
self.connect(self.pilot, (self.mix_stereo, 2))
self.connect(self.mix_stereo, self.audio_lmr_filter)
# create RDS bitstream
# diff-encode, manchester-emcode, NRZ
# enforce the 1187.5bps rate
# pulse shaping filter (matched with receiver)
# mix with 57kHz carrier (equivalent to BPSK)
self.rds_enc = rds.data_encoder('rds_data.xml')
self.diff_enc = gr.diff_encoder_bb(2)
self.manchester1 = gr.map_bb([1, 2])
self.manchester2 = gr.unpack_k_bits_bb(2)
self.nrz = gr.map_bb([-1, 1])
self.c2f = gr.char_to_float()
self.rate_enforcer = rds.rate_enforcer(usrp_rate)
pulse_shaping_taps = gr.firdes.low_pass(
1, # gain
usrp_rate, # sampling rate
1.5e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HAMMING)
self.pulse_shaping = gr.fir_filter_fff(1, pulse_shaping_taps)
self.bpsk_mod = gr.multiply_ff()
self.connect (self.rds_enc, self.diff_enc, self.manchester1, \
self.manchester2, self.nrz, self.c2f)
self.connect(self.c2f, (self.rate_enforcer, 0))
self.connect(self.pilot, (self.rate_enforcer, 1))
self.connect(self.rate_enforcer, (self.bpsk_mod, 0))
self.connect(self.pilot, (self.bpsk_mod, 1))
self.connect(self.pilot, (self.bpsk_mod, 2))
self.connect(self.pilot, (self.bpsk_mod, 3))
# RDS band-pass filter
rds_filter_taps = gr.firdes.band_pass(
50, # gain
usrp_rate, # sampling rate
57e3 - 3e3, # low cutoff
57e3 + 3e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.rds_filter = gr.fir_filter_fff(1, rds_filter_taps)
self.connect(self.bpsk_mod, self.rds_filter)
# mix L+R, pilot, L-R and RDS
self.mixer = gr.add_ff()
self.connect(self.audio_lpr_filter, (self.mixer, 0))
self.connect(self.pilot, (self.mixer, 1))
self.connect(self.audio_lmr_filter, (self.mixer, 2))
self.connect(self.rds_filter, (self.mixer, 3))
# fm modulation, gain & TX
max_dev = 75e3
k = 2 * math.pi * max_dev / usrp_rate # modulator sensitivity
self.modulator = gr.frequency_modulator_fc(k)
self.gain = gr.multiply_const_cc(5e3)
self.connect(self.mixer, self.modulator, self.gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
self.fft = fftsink2.fft_sink_f(panel,
title="Pre FM modulation",
fft_size=512 * 4,
sample_rate=usrp_rate,
y_per_div=20,
ref_level=-20)
self.connect(self.mixer, self.fft)
vbox.Add(self.fft.win, 1, wx.EXPAND)
if 0:
self.scope = scopesink2.scope_sink_f(panel,
title="RDS encoder output",
sample_rate=usrp_rate)
self.connect(self.rds_enc, self.scope)
vbox.Add(self.scope.win, 1, wx.EXPAND)
def __init__(self, frame, panel, vbox, argv):
MAX_CHANNELS = 7
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
parser.add_option("-f",
"--freq",
type="eng_float",
default=None,
help="set Tx frequency to FREQ [required]",
metavar="FREQ")
parser.add_option("-n",
"--nchannels",
type="int",
default=4,
help="number of Tx channels [1,4]")
#parser.add_option("","--debug", action="store_true", default=False,
# help="Launch Tx debugger")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.nchannels < 1 or options.nchannels > MAX_CHANNELS:
sys.stderr.write(
"fm_tx4: nchannels out of range. Must be in [1,%d]\n" %
MAX_CHANNELS)
sys.exit(1)
if options.freq is None:
sys.stderr.write("fm_tx4: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
# Set up constants and parameters
self.u = usrp.sink_c() # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
self.sw_interp = 10
self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
#print "mux = %#04x" % (m,)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.subdev.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(
options.freq), eng_notation.num_to_str(
freq_range[0]), eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True) # enable transmitter
sum = gr.add_cc()
# Instantiate N NBFM channels
step = 25e3
offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step,
-3 * step)
for i in range(options.nchannels):
t = pipeline("audio-%d.dat" % (i % 4), offset[i], self.audio_rate,
self.usrp_rate)
self.connect(t, (sum, i))
gain = gr.multiply_const_cc(4000.0 / options.nchannels)
# connect it all
self.connect(sum, gain)
self.connect(gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
post_mod = fftsink2.fft_sink_c(panel,
title="Post Modulation",
fft_size=512,
sample_rate=self.usrp_rate,
y_per_div=20,
ref_level=40)
self.connect(sum, post_mod)
vbox.Add(post_mod.win, 1, wx.EXPAND)
def __init__(self):
gr.top_block.__init__(self)
amplitude = 5000
interp_rate = 256
dec_rate = 16
sw_dec = 5
num_taps = int(64000 / ( (dec_rate * 4) * 40 )) #Filter matched to 1/4 of the 40 kHz tag cycle
taps = [complex(1,1)] * num_taps
matched_filt = gr.fir_filter_ccc(sw_dec, taps);
agc = gr.agc2_cc(0.3, 1e-3, 1, 1, 100)
to_mag = gr.complex_to_mag()
center = rfid.center_ff(10)
omega = 5
mu = 0.25
gain_mu = 0.25
gain_omega = .25 * gain_mu * gain_mu
omega_relative_limit = .05
mm = gr.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_relative_limit)
self.reader = rfid.reader_f(int(128e6/interp_rate));
tag_decoder = rfid.tag_decoder_f()
command_gate = rfid.command_gate_cc(12, 250, 64000000 / dec_rate / sw_dec)
to_complex = gr.float_to_complex()
amp = gr.multiply_const_ff(amplitude)
#output the TX and RX signals only
f_txout = gr.file_sink(gr.sizeof_gr_complex, 'f_txout.out');
f_rxout = gr.file_sink(gr.sizeof_gr_complex, 'f_rxout.out');
#TX
# working frequency at 915 MHz by default and RX Gain of 20
freq = options.center_freq #915e6
rx_gain = options.rx_gain #20
tx = usrp.sink_c(fusb_block_size = 512, fusb_nblocks=4)
tx.set_interp_rate(256)
tx_subdev = (0,0)
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev, freq)
if not t:
print "Couldn't set tx freq"
#End TX
#RX
rx = usrp.source_c(0, dec_rate, fusb_block_size = 512, fusb_nblocks = 4)
rx_subdev_spec = (1,0)
rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec))
rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec)
rx_subdev.set_gain(rx_gain)
rx_subdev.set_auto_tr(False)
rx_subdev.set_enable(True)
r = usrp.tune(rx, 0, rx_subdev, freq)
self.rx = rx
if not r:
print "Couldn't set rx freq"
#End RX
command_gate.set_ctrl_out(self.reader.ctrl_q())
tag_decoder.set_ctrl_out(self.reader.ctrl_q())
#########Build Graph
self.connect(rx, matched_filt)
self.connect(matched_filt, command_gate)
self.connect(command_gate, agc)
self.connect(agc, to_mag)
self.connect(to_mag, center, mm, tag_decoder)
self.connect(tag_decoder, self.reader, amp, to_complex, tx);
#################
#Output dumps for debug
self.connect(rx, f_rxout);
self.connect(to_complex, f_txout);
def __init__(self, frame, panel, vbox, argv):
MAX_CHANNELS = 7
stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B")
parser.add_option("-f", "--freq", type="eng_float", default=None,
help="set Tx frequency to FREQ [required]", metavar="FREQ")
parser.add_option("-n", "--nchannels", type="int", default=4,
help="number of Tx channels [1,4]")
#parser.add_option("","--debug", action="store_true", default=False,
# help="Launch Tx debugger")
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.nchannels < 1 or options.nchannels > MAX_CHANNELS:
sys.stderr.write ("fm_tx4: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS)
sys.exit(1)
if options.freq is None:
sys.stderr.write("fm_tx4: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
# Set up constants and parameters
self.u = usrp.sink_c () # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
self.sw_interp = 10
self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
#print "mux = %#04x" % (m,)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.subdev.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(options.freq),
eng_notation.num_to_str(freq_range[0]),
eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True) # enable transmitter
sum = gr.add_cc ()
# Instantiate N NBFM channels
step = 25e3
offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step, -3 * step)
for i in range (options.nchannels):
t = pipeline("audio-%d.dat" % (i % 4), offset[i],
self.audio_rate, self.usrp_rate)
self.connect(t, (sum, i))
gain = gr.multiply_const_cc (4000.0 / options.nchannels)
# connect it all
self.connect (sum, gain)
self.connect (gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation",
fft_size=512, sample_rate=self.usrp_rate,
y_per_div=20, ref_level=40)
self.connect (sum, post_mod)
vbox.Add (post_mod.win, 1, wx.EXPAND)
def __init__(self):
parser = OptionParser(option_class=eng_option)
parser.add_option(
"-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help=
"select USRP Tx side A or B (default=first one with a daughterboard)"
)
parser.add_option("-c",
"--cordic-freq1",
type="eng_float",
default=434845200,
help="set Tx cordic frequency to FREQ",
metavar="FREQ")
parser.add_option("-d",
"--cordic-freq2",
type="eng_float",
default=434318512,
help="set rx cordic frequency for channel 2 to FREQ",
metavar="FREQ")
parser.add_option("-g",
"--gain",
type="eng_float",
default=0,
help="set Rx PGA gain in dB [0,20]")
(options, args) = parser.parse_args()
print "cordic_freq1 = %s" % (eng_notation.num_to_str(
options.cordic_freq1))
print "cordic_freq2 = %s" % (eng_notation.num_to_str(
options.cordic_freq2))
# ----------------------------------------------------------------
self.data_rate = 38400
self.samples_per_symbol = 8
self.channel_fs = self.data_rate * self.samples_per_symbol
self.fs = 4e6
payload_size = 128 # bytes
print "data_rate = ", eng_notation.num_to_str(self.data_rate)
print "samples_per_symbol = ", self.samples_per_symbol
print "fs = ", eng_notation.num_to_str(self.fs)
gr.flow_graph.__init__(self)
self.normal_gain = 8000
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate()
self.interp = int(dac_rate / self.fs)
print "usrp interp = ", self.interp
self.u.set_interp_rate(self.interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
if options.cordic_freq1 < options.cordic_freq2:
self.usrp_freq = options.cordic_freq1
self.freq_diff = options.cordic_freq2 - options.cordic_freq1
else:
self.usrp_freq = options.cordic_freq2
self.freq_diff = options.cordic_freq1 - options.cordic_freq2
print "freq_diff = ", eng_notation.num_to_str(self.freq_diff)
self.u.tune(self.subdev._which, self.subdev, self.usrp_freq)
print "tune USRP to = ", eng_notation.num_to_str(self.usrp_freq)
self.u.set_pga(0, options.gain)
self.u.set_pga(1, options.gain)
interp_factor = int(self.fs / self.channel_fs)
quad_rate = self.fs
print "interp_factor = ", interp_factor
# Create filter for the interpolation
interp_taps = gr.firdes.low_pass(
interp_factor, # gain
self.channel_fs * interp_factor, # Fs
self.channel_fs / 2, # low pass cutoff freq
self.channel_fs * 0.1, # width of trans. band
gr.firdes.WIN_HANN) #filter type
print "len(interp_taps) =", len(interp_taps)
self.interpolator1 = gr.interp_fir_filter_ccc(interp_factor,
interp_taps)
self.interpolator2 = gr.interp_fir_filter_ccc(interp_factor,
interp_taps)
self.multiplicator = gr.multiply_cc()
self.adder = gr.add_cc()
self.sin = gr.sig_source_c(self.channel_fs * interp_factor,
gr.GR_SIN_WAVE, self.freq_diff, 1,
complex(0, 0))
# transmitter
self.packet_transmitter1 = cc1k_sos_pkt.cc1k_mod_pkts(
self, spb=self.samples_per_symbol, msgq_limit=2)
#self.packet_transmitter2 = cc1k_sos_pkt.cc1k_mod_pkts(self, spb=self.samples_per_symbol, msgq_limit=2)
self.amp = gr.multiply_const_cc(self.normal_gain)
self.filesink = gr.file_sink(gr.sizeof_gr_complex, 'tx_test.dat')
self.filesink2 = gr.file_sink(gr.sizeof_gr_complex, 'tx_test2.dat')
self.filesink3 = gr.file_sink(gr.sizeof_gr_complex, 'tx_test3.dat')
# interpolate the two transmitters
self.connect(self.packet_transmitter1, self.interpolator1)
#self.connect(self.packet_transmitter2, self.interpolator2)
# upconvert the first transmitter)
self.connect(self.interpolator1, (self.multiplicator, 1))
self.connect(self.sin, (self.multiplicator, 0))
# add the two signals
#self.connect(self.multiplicator, (self.adder, 0))
#self.connect(self.interpolator2, (self.adder, 1))
# send the signal to the USRP
self.connect(self.interpolator1, self.amp, self.filesink)
self.connect(self.multiplicator, self.filesink2)
self.connect(self.sin, self.filesink3)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def main():
parser = OptionParser(option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=(0, 0), help="select USRP Tx side A or B")
parser.add_option("-f", "--rf-freq", type="eng_float", default=None, help="set RF center frequency to FREQ")
parser.add_option(
"-i", "--interp", type="int", default=64, help="set fgpa interpolation rate to INTERP [default=%default]"
)
parser.add_option(
"--sine",
dest="type",
action="store_const",
const=gr.GR_SIN_WAVE,
help="generate a complex sinusoid [default]",
default=gr.GR_SIN_WAVE,
)
parser.add_option(
"--const", dest="type", action="store_const", const=gr.GR_CONST_WAVE, help="generate a constant output"
)
parser.add_option(
"--gaussian", dest="type", action="store_const", const=gr.GR_GAUSSIAN, help="generate Gaussian random output"
)
parser.add_option(
"--uniform", dest="type", action="store_const", const=gr.GR_UNIFORM, help="generate Uniform random output"
)
parser.add_option(
"-w", "--waveform-freq", type="eng_float", default=0, help="set waveform frequency to FREQ [default=%default]"
)
parser.add_option(
"-a",
"--amplitude",
type="eng_float",
default=16e3,
help="set waveform amplitude to AMPLITUDE [default=%default]",
metavar="AMPL",
)
parser.add_option("-g", "--gain", type="eng_float", default=None, help="set output gain to GAIN [default=%default]")
parser.add_option(
"-o", "--offset", type="eng_float", default=0, help="set waveform offset to OFFSET [default=%default]"
)
parser.add_option(
"-N", "--nsamples", type="eng_float", default=0, help="set number of samples to transmit [default=+inf]"
)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit
if options.rf_freq is None:
sys.stderr.write("usrp_siggen: must specify RF center frequency with -f RF_FREQ\n")
parser.print_help()
raise SystemExit
tb = my_top_block(options.nsamples)
tb.set_interpolator(options.interp)
tb.set_waveform_type(options.type)
tb.set_waveform_freq(options.waveform_freq)
tb.set_waveform_ampl(options.amplitude)
tb.set_waveform_offset(options.offset)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(tb.u)
m = usrp.determine_tx_mux_value(tb.u, options.tx_subdev_spec)
# print "mux = %#04x" % (m,)
tb.u.set_mux(m)
tb.subdev = usrp.selected_subdev(tb.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (tb.subdev.side_and_name(),)
if options.gain is None:
tb.subdev.set_gain(tb.subdev.gain_range()[1]) # set max Tx gain
else:
tb.subdev.set_gain(options.gain) # set max Tx gain
if not tb.set_freq(options.rf_freq):
sys.stderr.write("Failed to set RF frequency\n")
raise SystemExit
tb.subdev.set_enable(True) # enable transmitter
try:
tb.run()
except KeyboardInterrupt:
pass
def __init__(self, frame, panel, vbox, argv):
# Graphical part
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
# Config_____
tx_frequency = 14085000
usrp_interpolation = 400
usrp_tx_rate = 128000000
tx_side = 0
tx_dev = 0
audio_rate = 32000
tx_subdev = (tx_side, tx_dev)
usrp_tx_sample_rate = usrp_tx_rate / usrp_interpolation
def rtty_gen_f(samplerate, speed, textdata):
bitsamples = samplerate / speed
mark = 900
shift = 170
space = mark + shift
wavedata = []
letters = "_E\nA SIU\rDRJNFCKTZLWHYPQOBG_MXV_"
figures = "_3\n- '87\r_4_,!:(5+)2$6019?&_./;_"
keyshift = 0
for c in textdata:
chartable = letters
baudotdata = ''
shiftdata = ''
if ((c >= '!') and (c <= '9')):
if (not keyshift):
shiftdata = '[MMSMM]'
keyshift = 1
else:
if (keyshift):
shiftdata = '[MMMMM]'
keyshift = 0
baudotdata = ']' + baudotdata
if (keyshift):
chartable = figures
baudotval = chartable.find(c)
for b in (16, 8, 4, 2, 1):
if (baudotval >= b):
baudotdata = 'M' + baudotdata
baudotval = baudotval - b
else:
baudotdata = 'S' + baudotdata
baudotdata = shiftdata + '[' + baudotdata
for bit in baudotdata:
if (bit == 'M'):
bitval = mark
bitlen = 1
if (bit == 'S'):
bitval = space
bitlen = 1
if (bit == '['):
bitval = space
bitlen = 1
if (bit == ']'):
bitval = mark
bitlen = 1.5
for s in range(0, bitlen * bitsamples):
wavedata.append(bitval)
return gr.vector_source_f(wavedata, True)
ryry = "RYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRYRY\r\n"
callsign = "ZCZC DE PA3FKM PA3FKM -- RUNNING GNURADIO -- \r\n"
fox = "+-- THE QUICK BROWN FOX JUMPED OVER THE LAZY DOG --+\r\n "
rttymsg = ryry + ryry + callsign + fox + "(0123456789)\r\n"
callgever = rtty_gen_f(audio_rate, 45, rttymsg)
lpf_coeffs = gr.firdes.low_pass(1, audio_rate, 5000, 200)
lpf = gr.fir_filter_fff(1, lpf_coeffs)
fsk_f = gr.vco_f(audio_rate, 2 * pi, 0.5)
fsk_c = gr.hilbert_fc(audio_rate / 300)
# IF low pass filter
lpf_tx_coeffs = gr.firdes.low_pass(32000, audio_rate, 2000, 1000)
# Interpolation to usrp sample frequency
fsk_resample = blks2.rational_resampler_ccc(usrp_tx_sample_rate /
audio_rate,
1,
taps=lpf_tx_coeffs)
usrp_tx = usrp.sink_c(0, usrp_interpolation)
self.usrp_tx = usrp_tx
speaker = audio.sink(audio_rate, "plughw:0,0")
self.connect(callgever, lpf, fsk_f)
self.connect(fsk_f, fsk_c, fsk_resample, usrp_tx)
#self.connect(fsk_f, speaker)
# Set Multiplexer
mux = usrp.determine_tx_mux_value(usrp_tx, tx_subdev)
usrp_tx.set_mux(mux)
# Select subdevice
usrp_tx_subdev = usrp.selected_subdev(usrp_tx, tx_subdev)
# Tune subdevice
usrp_tx.tune(usrp_tx_subdev._which, usrp_tx_subdev, tx_frequency)
# Enable Transmitter (Required if using one of the Flex boards)
usrp_tx_subdev.set_enable(True)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
parser.add_option("-f",
"--freq",
type="eng_float",
default=107.2e6,
help="set Tx frequency to FREQ [required]",
metavar="FREQ")
parser.add_option("--wavfile",
type="string",
default="",
help="read input from FILE")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.usrp_interp = 200
self.u = usrp.sink_c(0, self.usrp_interp)
print "USRP Serial: ", self.u.serial_number()
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_rate = self.dac_rate / self.usrp_interp # 640 kS/s
self.sw_interp = 5
self.audio_rate = self.usrp_rate / self.sw_interp # 128 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using d'board: ", self.subdev.side_and_name()
# set max Tx gain, tune frequency and enable transmitter
self.subdev.set_gain(self.subdev.gain_range()[1])
if self.u.tune(self.subdev.which(), self.subdev, options.freq):
print "Tuned to", options.freq / 1e6, "MHz"
else:
sys.exit(1)
self.subdev.set_enable(True)
# open wav file containing floats in the [-1, 1] range, repeat
if options.wavfile is None:
print "Please provide a wavfile to transmit! Exiting\n"
sys.exit(1)
self.src = gr.wavfile_source(options.wavfile, True)
nchans = self.src.channels()
sample_rate = self.src.sample_rate()
bits_per_sample = self.src.bits_per_sample()
print nchans, "channels,", sample_rate, "kS/s,", bits_per_sample, "bits/sample"
# resample to 128kS/s
if sample_rate == 44100:
self.resample_left = blks2.rational_resampler_fff(32, 11)
self.resample_right = blks2.rational_resampler_fff(32, 11)
elif sample_rate == 48000:
self.resample_left == blks2.rational_resampler_fff(8, 3)
self.resample_right == blks2.rational_resampler_fff(8, 3)
elif sample_rate == 8000:
self.resample_left == blks2.rational_resampler_fff(16, 1)
self.resample_right == blks2.rational_resampler_fff(16, 1)
else:
print sample_rate, "is an unsupported sample rate"
sys.exit(1)
self.connect((self.src, 0), self.resample_left)
self.connect((self.src, 1), self.resample_right)
# create L+R (mono) and L-R (stereo)
self.audio_lpr = gr.add_ff()
self.audio_lmr = gr.sub_ff()
self.connect(self.resample_left, (self.audio_lpr, 0))
self.connect(self.resample_left, (self.audio_lmr, 0))
self.connect(self.resample_right, (self.audio_lpr, 1))
self.connect(self.resample_right, (self.audio_lmr, 1))
# low-pass filter for L+R
audio_lpr_taps = gr.firdes.low_pass(
0.3, # gain
self.audio_rate, # sampling rate
15e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HANN)
self.audio_lpr_filter = gr.fir_filter_fff(1, audio_lpr_taps)
self.connect(self.audio_lpr, self.audio_lpr_filter)
# create pilot tone at 19 kHz
self.pilot = gr.sig_source_f(
self.audio_rate, # sampling freq
gr.GR_SIN_WAVE, # waveform
19e3, # frequency
3e-2) # amplitude
# create the L-R signal carrier at 38 kHz, high-pass to remove 0Hz tone
self.stereo_carrier = gr.multiply_ff()
self.connect(self.pilot, (self.stereo_carrier, 0))
self.connect(self.pilot, (self.stereo_carrier, 1))
stereo_carrier_taps = gr.firdes.high_pass(
1, # gain
self.audio_rate, # sampling rate
1e4, # cutoff freq
2e3, # transition width
gr.firdes.WIN_HANN)
self.stereo_carrier_filter = gr.fir_filter_fff(1, stereo_carrier_taps)
self.connect(self.stereo_carrier, self.stereo_carrier_filter)
# upconvert L-R to 23-53 kHz and band-pass
self.mix_stereo = gr.multiply_ff()
audio_lmr_taps = gr.firdes.band_pass(
3e3, # gain
self.audio_rate, # sampling rate
23e3, # low cutoff
53e3, # high cuttof
2e3, # transition width
gr.firdes.WIN_HANN)
self.audio_lmr_filter = gr.fir_filter_fff(1, audio_lmr_taps)
self.connect(self.audio_lmr, (self.mix_stereo, 0))
self.connect(self.stereo_carrier_filter, (self.mix_stereo, 1))
self.connect(self.mix_stereo, self.audio_lmr_filter)
# mix L+R, pilot and L-R
self.mixer = gr.add_ff()
self.connect(self.audio_lpr_filter, (self.mixer, 0))
self.connect(self.pilot, (self.mixer, 1))
self.connect(self.audio_lmr_filter, (self.mixer, 2))
# interpolation & pre-emphasis
interp_taps = gr.firdes.low_pass(
self.sw_interp, # gain
self.audio_rate, # Fs
60e3, # cutoff freq
5e3, # transition width
gr.firdes.WIN_HAMMING)
self.interpolator = gr.interp_fir_filter_fff(self.sw_interp,
interp_taps)
self.pre_emph = blks2.fm_preemph(self.usrp_rate, tau=50e-6)
self.connect(self.mixer, self.interpolator, self.pre_emph)
# fm modulation, gain & TX
max_dev = 100e3
k = 2 * math.pi * max_dev / self.usrp_rate # modulator sensitivity
self.modulator = gr.frequency_modulator_fc(k)
self.gain = gr.multiply_const_cc(1e3)
self.connect(self.pre_emph, self.modulator, self.gain, self.u)
# plot an FFT to verify we are sending what we want
pre_mod = fftsink2.fft_sink_f(panel,
title="Before Interpolation",
fft_size=512,
sample_rate=self.audio_rate,
y_per_div=20,
ref_level=20)
self.connect(self.mixer, pre_mod)
vbox.Add(pre_mod.win, 1, wx.EXPAND)
def main():
# Parsing command line parameter
parser = OptionParser(option_class=eng_option)
parser.add_option(
"-f",
"--freq",
type="eng_float",
dest="freq",
default=866.5,
help="set USRP center frequency (provide frequency in MHz)")
parser.add_option("-m",
"--miller",
type="int",
dest="miller",
default=2,
help="set number of Miller subcarriers (2,4 or 8)")
(options, args) = parser.parse_args()
which_usrp = 0
fpga = "gen2_reader_2ch_mod_pwr.rbf" # Modified firmware --> you can set TX amplitude directly from Python (see below)
freq = options.freq # Default value = 866.5 --> center frequency of 2 MHz European RFID Band
freq = freq * 1e6
miller = options.miller
deviation_corr = 1 # Maximum deviation for Early/Late gate correlator in Buettner's reader
amplitude = 30000 # Amplitude of READER TX signal. 30000 is the maximum allowed.
rx_gain = 20
us_per_sample = float(1 / (64.0 / (dec_rate * sw_dec)))
samp_freq = (64 / dec_rate) * 1e6
# BUETTNER'S READER HARDWARE SUB-SYSTEM for TX SIDE
tx = usrp.sink_c(which_usrp,
fusb_block_size=1024,
fusb_nblocks=4,
fpga_filename=fpga)
tx.set_interp_rate(interp)
tx_subdev = (0, 0) # TX/RX port of RFX900 daugtherboard on SIDE A
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev,
freq) # Tuning TX Daughterboard @ Center Frequency
if not t:
print "Couldn't set READER TX frequency"
tx._write_fpga_reg(usrp.FR_USER_1, int(
amplitude)) # SET FPGA register value with the desired tx amplitude
# END BUETTNER'S READER HARDWARE SUB-SYSTEM for TX SIDE
# BUETTNER'S READER HARDWARE SUB-SYSTEM for RX SIDE
rx = usrp.source_c(
which_usrp,
dec_rate,
nchan=2,
fusb_block_size=512,
fusb_nblocks=16,
fpga_filename=fpga) # USRP source: 2 channels (reader + listener)
rx.set_mux(rx.determine_rx_mux_value(
(0, 0), (1, 0)
)) # 2 channel mux --> rx from (0,0) to reader - rx from (1,0) to listener
rx_reader_subdev_spec = (0, 0) # Reader RFX900 daugtherboard on SIDE A
rx_reader_subdev = rx.selected_subdev(rx_reader_subdev_spec)
rx_reader_subdev.set_gain(rx_gain)
rx_reader_subdev.set_auto_tr(False)
rx_reader_subdev.set_enable(True)
rx_reader_subdev.select_rx_antenna(
'RX2'
) # RX2 port of RFX900 on side A --> RX antenna of Buettner's reader
r = usrp.tune(rx, 0, rx_reader_subdev,
freq) # Tuning READER RX Daughterboard @ Center Frequency
if not r:
print "Couldn't set READER RX frequency"
# END BUETTNER'S READER HARDWARE SUB-SYSTEM for TX SIDE
# LISTENER HARDWARE SUB-SYSTEM
rx_listener_subdev_spec = (1, 0) # Listener DB RFX900 on side B
rx_listener_subdev = rx.selected_subdev(rx_listener_subdev_spec)
rx_listener_subdev.set_gain(rx_gain)
rx_listener_subdev.set_auto_tr(False)
rx_listener_subdev.set_enable(True)
rx_listener_subdev.select_rx_antenna(
'RX2'
) # RX Antenna on RX2 Connector of side B RFX900 (comment this line if you want TX/RX connector)
r = usrp.tune(rx, 1, rx_listener_subdev,
freq) # Tuning Listener Daughterboard @ Center Frequency
if not r:
print "Couldn't set LISTENER RX frequency"
# END LISTENER HARDWARE SUB-SYSTEM
print ""
print "********************************************************"
print "************ Gen2 RFID Monitoring Platform *************"
print "********* Reader and Listener on the same USRP *********"
print "********************************************************\n"
print "USRP center frequency: %s MHz" % str(freq / 1e6)
print "Sampling Frequency: " + str(
samp_freq /
1e6) + " MHz" + " --- microsec. per Sample: " + str(us_per_sample)
# BUETTNER's READER SOFTWARE SUB-SYSTEM (GNU-Radio flow-graph)
gen2_reader = rfid.gen2_reader(dec_rate * sw_dec * samples_per_pulse,
interp, int(miller), True,
int(deviation_corr))
zc = rfid.clock_recovery_zc_ff(samples_per_pulse, 1, float(us_per_sample),
float(up_link_freq), True)
# END BUETTNER's READER SOFTWARE SUB-SYSTEM (GNU-Radio flow-graph)
# LISTENER SOFTWARE SUB-SYSTEM (GNU-Radio flow-graph)
# MATCHED FILTER
num_taps = int(
64000 / (dec_rate * up_link_freq * 4)) #Matched filter for 1/4 cycle
taps = [complex(1, 1)] * num_taps
matched_filter = gr.fir_filter_ccc(sw_dec, taps)
# Tag Decoding Block --> the boolean value in input indicate if real-time output of EPC is enabled or not
tag_monitor = listener.tag_monitor(True, int(miller), float(up_link_freq))
# Clock recovery
cr = listener.clock_recovery(samples_per_pulse, us_per_sample,
tag_monitor.STATE_PTR, float(up_link_freq))
# Reader Decoding Block and Command gate--> the boolean value indicate if real-time output of reader commands is enabled or not
reader_monitor_cmd_gate = listener.reader_monitor_cmd_gate(
False, us_per_sample, tag_monitor.STATE_PTR, float(up_link_freq),
float(rtcal))
# END LISTENER SOFTWARE SUB-SYSTEM (GNU-Radio flow-graph)
# Create GNU-Radio flow-graph
tb = my_top_block(tx, zc, gen2_reader, rx, matched_filter,
reader_monitor_cmd_gate, cr, tag_monitor, amplitude)
# Start application
tb.start()
# GETTING LOGs from BUETTNER's READER
video_output = False # Set as True if you want real time video output of Buettner's reader logs
log_reader_buettner_file = open("log_reader_buettner.log", "w")
finish = 0
succ_reads = 0
epc_errors = 0
while 1:
log_reader_buettner = gen2_reader.get_log()
i = log_reader_buettner.count()
for k in range(0, i):
msg = log_reader_buettner.delete_head_nowait()
print_msg(msg, log_reader_buettner_file, video_output)
if msg.type() == 99: # All cycles are terminated
finish = 1
if msg.type() == LOG_EPC: # EPC
if msg.arg2() == LOG_ERROR:
epc_errors = epc_errors + 1
# CRC Error on EPC
else:
succ_reads = succ_reads + 1
# Successful EPc
if finish:
break
# Stop application
tb.stop()
log_reader_buettner_file.close()
rec_frames = succ_reads + epc_errors
print "\nReader --> Total Received Frames: " + str(rec_frames)
print "Reader --> Successful reads: " + str(succ_reads)
print "Reader --> CRC error frames: " + str(epc_errors)
print ""
# GETTING LOGs from LISTENER
log_READER = reader_monitor_cmd_gate.get_reader_log()
log_TAG = tag_monitor.get_tag_log()
print "Listener collected %s Entries for READER LOG" % str(
log_READER.count())
print "Listener collected %s Entries for TAG LOG" % str(log_TAG.count())
c = raw_input("PRESS 'f' to write LOG files, 'q' to QUIT\n")
if c == "q":
print "\n Shutting Down...\n"
return
if c == "f":
print "\n Writing READER LOG on file...\n\n"
reader_file = open("reader_log.out", "w")
reader_file.close()
reader_file = open("reader_log.out", "a")
i = log_READER.count()
for k in range(0, i):
decode_reader_log_msg(log_READER.delete_head_nowait(), reader_file)
k = k + 1
reader_file.close()
print "\n Writing TAG LOG on file...\n"
tag_file = open("tag_log.out", "w")
tag_file.close()
tag_file = open("tag_log.out", "a")
i = log_TAG.count()
for k in range(0, i):
decode_tag_log_msg(log_TAG.delete_head_nowait(), tag_file)
k = k + 1
tag_file.close()
def main():
parser = OptionParser(option_class=eng_option)
parser.add_option("-f",
"--freq",
type="eng_float",
default=144.800e6,
help="set frequency to FREQ",
metavar="FREQ")
parser.add_option("-m",
"--message",
type="string",
default=":ALL :this is a test",
help="message to send",
metavar="MESSAGE")
parser.add_option("-c",
"--mycall",
type="string",
default="MYCALL",
help="source callsign",
metavar="CALL")
parser.add_option("-t",
"--tocall",
type="string",
default="CQ",
help="recipient callsign",
metavar="CALL")
parser.add_option("-v",
"--via",
type="string",
default="RELAY",
help="digipeater callsign",
metavar="CALL")
parser.add_option("-d",
"--do-logging",
action="store_true",
default=False,
help="enable logging on datafiles")
parser.add_option("-s",
"--use-datafile",
action="store_true",
default=False,
help="use usrp.dat (256kbps) as output")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
bitrate = 9600
dac_rate = 128e6
usrp_interp = 500
cordic_freq = options.freq - dac_rate
sf = 153600
syminterp = sf / bitrate #16
nbfmdev = 3e3
fmsens = 2 * pi * nbfmdev / (sf * 5 / 3)
bit_oversampling = 8
sw_interp = int(sf / bitrate / bit_oversampling) #2
fg = gr.flow_graph()
p = buildpacket(options.mycall, 0, options.tocall, 0, options.via, 0, 0x03,
0xf0, options.message)
if options.do_logging:
dumppackettofile(p, "packet.dat")
v = bits2syms(nrziencode(scrambler(hdlcpacket(p, 100, 1000))))
src = gr.vector_source_f(v)
gaussian_taps = gr.firdes.gaussian(
1, # gain
bit_oversampling, # symbol_rate
0.3, # bandwidth * symbol time
4 * bit_oversampling # number of taps
)
sqwave = (1, ) * syminterp #rectangular window
taps = Numeric.convolve(Numeric.array(gaussian_taps),
Numeric.array(sqwave))
gaussian = gr.interp_fir_filter_fff(syminterp, taps) #9600*16=153600
res_taps = blks.design_filter(5, 3, 0.4)
res = blks.rational_resampler_fff(fg, 5, 3, res_taps) #153600*5/3=256000
fmmod = gr.frequency_modulator_fc(fmsens)
amp = gr.multiply_const_cc(32000)
if options.use_datafile:
dst = gr.file_sink(gr.sizeof_gr_complex, "usrp.dat")
else:
u = usrp.sink_c(0, usrp_interp) #256000*500=128000000
tx_subdev_spec = usrp.pick_tx_subdevice(u)
m = usrp.determine_tx_mux_value(u, tx_subdev_spec)
print "mux = %#04x" % (m, )
u.set_mux(m)
subdev = usrp.selected_subdev(u, tx_subdev_spec)
print "Using TX d'board %s" % (subdev.side_and_name(), )
u.set_tx_freq(0, cordic_freq)
u.set_pga(0, 0)
print "Actual frequency: ", u.tx_freq(0)
dst = u
fg.connect(src, gaussian, res, fmmod, amp, dst)
fg.start()
fg.wait()
def __init__(self):
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B (default=first one with a daughterboard)")
parser.add_option ("-c", "--cordic-freq", type="eng_float", default=434845200,
help="set Tx cordic frequency to FREQ", metavar="FREQ")
parser.add_option ("-r", "--data-rate", type="eng_float", default=38400)
parser.add_option ("-f", "--filename", type="string",
default="rx.dat", help="write data to FILENAME")
parser.add_option ("-g", "--gain", type="eng_float", default=0,
help="set Rx PGA gain in dB [0,20]")
parser.add_option ("-N", "--no-gui", action="store_true", default=False)
(options, args) = parser.parse_args ()
print "cordic_freq = %s" % (eng_notation.num_to_str (options.cordic_freq))
# ----------------------------------------------------------------
self.data_rate = options.data_rate
self.samples_per_symbol = 8
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 "fs = ", eng_notation.num_to_str(self.fs)
gr.flow_graph.__init__(self)
self.normal_gain = 8000
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate();
self.interp = int(128e6 / self.samples_per_symbol / self.data_rate)
print "usrp interp = ", self.interp
self.fs = 128e6 / self.interp
self.u.set_interp_rate(self.interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.u.tune(self.subdev._which, self.subdev, options.cordic_freq)
self.u.set_pga(0, options.gain)
self.u.set_pga(1, options.gain)
# transmitter
self.packet_transmitter = cc1k_sos_pkt.cc1k_mod_pkts(self, spb=self.samples_per_symbol, msgq_limit=2)
self.amp = gr.multiply_const_cc (self.normal_gain)
self.filesink = gr.file_sink(gr.sizeof_gr_complex, 'tx_test.dat')
self.connect(self.amp, self.filesink)
self.connect(self.packet_transmitter, self.amp, self.u)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self, frame, panel, vbox, argv):
MAX_CHANNELS = 7
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
parser.add_option("-e",
"--enable-fft",
action="store_true",
default=False,
help="enable spectrum plot (and use more CPU)")
parser.add_option("-f",
"--freq",
type="eng_float",
default=None,
help="set Tx frequency to FREQ [required]",
metavar="FREQ")
parser.add_option("-i",
"--file-input",
action="store_true",
default=False,
help="input from baseband-0.dat, baseband-1.dat ...")
parser.add_option("-g",
"--audio-gain",
type="eng_float",
default=1.0,
help="input audio gain multiplier")
parser.add_option("-n",
"--nchannels",
type="int",
default=2,
help="number of Tx channels [1,4]")
parser.add_option("-a",
"--udp-addr",
type="string",
default="127.0.0.1",
help="UDP host IP address")
parser.add_option("-p",
"--udp-port",
type="int",
default=0,
help="UDP port number")
parser.add_option("-r",
"--repeat",
action="store_true",
default=False,
help="continuously replay input file")
parser.add_option("-S",
"--stretch",
type="int",
default=0,
help="elastic buffer trigger value")
parser.add_option("-v",
"--verbose",
action="store_true",
default=False,
help="print out stats")
parser.add_option(
"-I",
"--audio-input",
type="string",
default="",
help="pcm input device name. E.g., hw:0,0 or /dev/dsp")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.nchannels < 1 or options.nchannels > MAX_CHANNELS:
sys.stderr.write(
"op25_tx: nchannels out of range. Must be in [1,%d]\n" %
MAX_CHANNELS)
sys.exit(1)
if options.freq is None:
sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
# Set up constants and parameters
self.u = usrp.sink_c() # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
self.sw_interp = 10
self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
#print "mux = %#04x" % (m,)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.subdev.set_gain(self.subdev.gain_range()[0]) # set min Tx gain
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(
options.freq), eng_notation.num_to_str(
freq_range[0]), eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True) # enable transmitter
# instantiate vocoders
self.vocoders = []
if options.file_input:
for i in range(options.nchannels):
t = gr.file_source(gr.sizeof_char, "baseband-%d.dat" % i,
options.repeat)
self.vocoders.append(t)
elif options.udp_port > 0:
self.udp_sources = []
for i in range(options.nchannels):
t = gr.udp_source(1, options.udp_addr, options.udp_port + i,
216)
self.udp_sources.append(t)
arity = 2
t = gr.packed_to_unpacked_bb(arity, gr.GR_MSB_FIRST)
self.vocoders.append(t)
self.connect(self.udp_sources[i], self.vocoders[i])
else:
self.audio_amps = []
self.converters = []
input_audio_rate = 8000
self.audio_input = audio.source(input_audio_rate,
options.audio_input)
for i in range(options.nchannels):
t = gr.multiply_const_ff(32767 * options.audio_gain)
self.audio_amps.append(t)
t = gr.float_to_short()
self.converters.append(t)
t = repeater.vocoder(
True, # 0=Decode,True=Encode
options.verbose, # Verbose flag
options.stretch, # flex amount
"", # udp ip address
0, # udp port
False) # dump raw u vectors
self.vocoders.append(t)
self.connect((self.audio_input, i), self.audio_amps[i],
self.converters[i], self.vocoders[i])
sum = gr.add_cc()
# Instantiate N NBFM channels
step = 25e3
offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step,
-3 * step)
for i in range(options.nchannels):
t = pipeline(self.vocoders[i], offset[i], self.audio_rate,
self.usrp_rate)
self.connect(t, (sum, i))
gain = gr.multiply_const_cc(4000.0 / options.nchannels)
# connect it all
self.connect(sum, gain)
self.connect(gain, self.u)
# plot an FFT to verify we are sending what we want
if options.enable_fft:
post_mod = fftsink2.fft_sink_c(panel,
title="Post Modulation",
fft_size=512,
sample_rate=self.usrp_rate,
y_per_div=20,
ref_level=40)
self.connect(sum, post_mod)
vbox.Add(post_mod.win, 1, wx.EXPAND)
def __init__(self):
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B (default=first one with a daughterboard)")
parser.add_option ("-c", "--cordic-freq1", type="eng_float", default=434845200,
help="set Tx cordic frequency to FREQ", metavar="FREQ")
parser.add_option ("-d", "--cordic-freq2", type="eng_float", default=434318512,
help="set rx cordic frequency for channel 2 to FREQ", metavar="FREQ")
parser.add_option ("-g", "--gain", type="eng_float", default=0,
help="set Rx PGA gain in dB [0,20]")
(options, args) = parser.parse_args ()
print "cordic_freq1 = %s" % (eng_notation.num_to_str (options.cordic_freq1))
print "cordic_freq2 = %s" % (eng_notation.num_to_str (options.cordic_freq2))
# ----------------------------------------------------------------
self.data_rate = 38400
self.samples_per_symbol = 8
self.channel_fs = self.data_rate * self.samples_per_symbol
self.fs = 4e6
payload_size = 128 # bytes
print "data_rate = ", eng_notation.num_to_str(self.data_rate)
print "samples_per_symbol = ", self.samples_per_symbol
print "fs = ", eng_notation.num_to_str(self.fs)
gr.flow_graph.__init__(self)
self.normal_gain = 8000
self.u = usrp.sink_c()
dac_rate = self.u.dac_rate();
self.interp = int(dac_rate / self.fs )
print "usrp interp = ", self.interp
self.u.set_interp_rate(self.interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
if options.cordic_freq1 < options.cordic_freq2:
self.usrp_freq = options.cordic_freq1
self.freq_diff = options.cordic_freq2 - options.cordic_freq1
else:
self.usrp_freq = options.cordic_freq2
self.freq_diff = options.cordic_freq1 - options.cordic_freq2
print "freq_diff = ", eng_notation.num_to_str(self.freq_diff)
self.u.tune(self.subdev._which, self.subdev, self.usrp_freq)
print "tune USRP to = ", eng_notation.num_to_str(self.usrp_freq)
self.u.set_pga(0, options.gain)
self.u.set_pga(1, options.gain)
interp_factor = int(self.fs / self.channel_fs)
quad_rate = self.fs
print "interp_factor = ", interp_factor
# Create filter for the interpolation
interp_taps = gr.firdes.low_pass (interp_factor, # gain
self.channel_fs*interp_factor, # Fs
self.channel_fs/2, # low pass cutoff freq
self.channel_fs*0.1,# width of trans. band
gr.firdes.WIN_HANN) #filter type
print "len(interp_taps) =", len(interp_taps)
self.interpolator1 = gr.interp_fir_filter_ccc(interp_factor, interp_taps)
self.interpolator2 = gr.interp_fir_filter_ccc(interp_factor, interp_taps)
self.multiplicator = gr.multiply_cc()
self.adder = gr.add_cc()
self.sin = gr.sig_source_c(self.channel_fs * interp_factor, gr.GR_SIN_WAVE, self.freq_diff, 1, complex(0, 0))
# transmitter
self.packet_transmitter1 = cc1k_sos_pkt.cc1k_mod_pkts(self, spb=self.samples_per_symbol, msgq_limit=2)
#self.packet_transmitter2 = cc1k_sos_pkt.cc1k_mod_pkts(self, spb=self.samples_per_symbol, msgq_limit=2)
self.amp = gr.multiply_const_cc (self.normal_gain)
self.filesink = gr.file_sink(gr.sizeof_gr_complex, 'tx_test.dat')
self.filesink2 = gr.file_sink(gr.sizeof_gr_complex, 'tx_test2.dat')
self.filesink3 = gr.file_sink(gr.sizeof_gr_complex, 'tx_test3.dat')
# interpolate the two transmitters
self.connect(self.packet_transmitter1, self.interpolator1)
#self.connect(self.packet_transmitter2, self.interpolator2)
# upconvert the first transmitter)
self.connect(self.interpolator1, (self.multiplicator, 1))
self.connect(self.sin, (self.multiplicator, 0))
# add the two signals
#self.connect(self.multiplicator, (self.adder, 0))
#self.connect(self.interpolator2, (self.adder, 1))
# send the signal to the USRP
self.connect(self.interpolator1, self.amp, self.filesink)
self.connect(self.multiplicator, self.filesink2)
self.connect(self.sin, self.filesink3)
self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def main():
#TX
which_usrp = 0
fpga = "gen2_reader.rbf"
freq = 915e6
rx_gain = 20
samp_freq = (64 / dec_rate) * 1e6
tx = usrp.sink_c(which_usrp,fusb_block_size = 1024, fusb_nblocks=4, fpga_filename=fpga)
tx.set_interp_rate(interp)
tx_subdev = (0,0)
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev, freq)
if not t:
print "Couldn't set tx freq"
#End TX
#RX
rx = usrp.source_c(which_usrp, dec_rate, fusb_block_size = 512, fusb_nblocks = 16, fpga_filename=fpga)
rx_subdev_spec = (1,0)
rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec))
rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec)
rx_subdev.set_gain(rx_gain)
rx_subdev.set_auto_tr(False)
rx_subdev.set_enable(True)
us_per_sample = 1 / (64.0 / dec_rate / sw_dec)
print "Sample Frequency: "+ str(samp_freq) + " us Per Sample: " + str(us_per_sample)
r = usrp.tune(rx, 0, rx_subdev, freq)
if not r:
print "Couldn't set rx freq"
#End RX
gen2_reader = rfid.gen2_reader(dec_rate * sw_dec * samples_per_pulse, interp)
tb = my_top_block(rx, gen2_reader, tx)
tb.start()
log_file = open("log_out.log", "w")
while 1:
c = raw_input("'Q' to quit\n")
if c == "q":
break
if c == "A" or c == "a":
log_file.write("T,CMD,ERROR,BITS,SNR\n")
log = gen2_reader.get_log()
print "Log has %s Entries"% (str(log.count()))
i = log.count();
for k in range(0, i):
msg = log.delete_head_nowait()
print_log_msg(msg, log_file)
tb.stop()
log_file.close()
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B")
parser.add_option("-f", "--freq", type="eng_float", default=107.2e6,
help="set Tx frequency to FREQ [required]", metavar="FREQ")
parser.add_option("-i", "--filename", type="string", default="",
help="read input from FILE")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
self.u = usrp.sink_c ()
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
self.sw_interp = 10
self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
# set max Tx gain, tune frequency and enable transmitter
self.subdev.set_gain(self.subdev.gain_range()[1])
self.u.tune(self.subdev._which, self.subdev, options.freq)
self.subdev.set_enable(True)
# open file containing floats in the [-1, 1] range, repeat
self.src = gr.wavfile_source (options.filename, True)
nchans = self.src.channels()
sample_rate = self.src.sample_rate()
bits_per_sample = self.src.bits_per_sample()
print nchans, "channels,", sample_rate, "kS/s,", bits_per_sample, "bits/sample"
# resample to 32kS/s
if sample_rate == 44100:
self.resample = blks2.rational_resampler_fff(8,11)
elif sample_rate == 48000:
self.resample == blks2.rational_resampler_fff(2,3)
else:
print sample_rate, "is an unsupported sample rate"
exit()
# interpolation, preemphasis, fm modulation & gain
self.fmtx = blks2.wfm_tx (self.audio_rate, self.usrp_rate, tau=75e-6, max_dev=15e3)
self.gain = gr.multiply_const_cc (4e3)
# connect it all
self.connect (self.src, self.resample, self.fmtx, self.gain, self.u)
# plot an FFT to verify we are sending what we want
pre_mod = fftsink2.fft_sink_f(panel, title="Pre-Modulation",
fft_size=512, sample_rate=self.usrp_rate, y_per_div=10, ref_level=0)
self.connect (self.emph, pre_mod)
vbox.Add (pre_mod.win, 1, wx.EXPAND)
def __init__(self, parent, ID, title):
wxFrame.__init__(self, parent, ID, title,
wxDefaultPosition)
self.pga = 0
self.pgaMin = -20
self.pgaMax = 0
self.pgaStep = 0.25
# Parsing options
parser = OptionParser(option_class=eng_option,
usage="usage: %prog [options] filename1" \
" [-f frequency2 filename2 [...]]")
parser.add_option("-a", "--agc", action="store_true",
help="enable agc")
parser.add_option("-c", "--clockrate", type="eng_float", default=128e6,
help="set USRP clock rate (128e6)")
parser.add_option("--copy", action="store_true",
help="enable real to imag data copy when in real mode")
parser.add_option("-e", "--encoding", type="choice", choices=["s", "f"],
default="f", help="choose data encoding: [s]igned or [f]loat.")
parser.add_option("-f", "--frequency", type="eng_float",
action="callback", callback=appendFrequency,
help="set output frequency (222.064e6)")
parser.add_option("-g", "--gain", type="float",
help="set output pga gain")
parser.add_option("-l", "--list", action="callback", callback=listUsrp,
help="list USRPs and daugtherboards")
parser.add_option("-m", "--mode", type="eng_float", default=2,
help="mode: 1: real, 2: complex (2)")
parser.add_option("-o", "--osc", action="store_true",
help="enable oscilloscope")
parser.add_option("-r", "--samplingrate", type="eng_float",
default=3.2e6,
help="set input sampling rate (3200000)")
parser.add_option("-s", "--spectrum", action="store_true",
help="enable spectrum analyzer")
# parser.add_option("-t", "--tx", type="choice", choices=["A", "B"],
# default="A", help="choose USRP tx A|B output (A)")
parser.add_option("-u", "--usrp", action="store_true",
help="enable USRP output")
(options, args) = parser.parse_args()
if len(args) == 0 :
options.filename = [ "/dev/stdin" ]
else :
options.filename = args
# Setting default frequency
if options.frequency is None :
options.frequency = [ 222.064e6 ]
if len(options.filename) != len(options.frequency) :
parser.error("Nb input file != nb frequency!")
# Status bar
# self.CreateStatusBar(3, 0)
# msg = "PGA: %.2f dB" % (self.pga * self.pgaStep)
# self.SetStatusText(msg, 1)
# msg = "Freq: %.3f mHz" % (options.frequency[0] / 1000000.0)
# self.SetStatusText(msg, 2)
# Menu bar
menu = wxMenu()
menu.Append(ID_ABOUT, "&About",
"More information about this program")
menu.AppendSeparator()
menu.Append(ID_EXIT, "E&xit", "Terminate the program")
menuBar = wxMenuBar()
menuBar.Append(menu, "&File")
self.SetMenuBar(menuBar)
# Main windows
mainSizer = wxFlexGridSizer(0, 1)
sliderSizer = wxFlexGridSizer(0, 2)
buttonSizer = wxBoxSizer(wxHORIZONTAL)
if options.usrp :
# TX d'board 0
gainLabel = wxStaticText(self, -1, "PGA 0")
gainSlider = wxSlider(self, ID_GAIN_SLIDER0, self.pga,
self.pgaMin / self.pgaStep, self.pgaMax / self.pgaStep,
style = wxSL_HORIZONTAL | wxSL_AUTOTICKS)
gainSlider.SetSize((400, -1))
sliderSizer.Add(gainLabel, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
sliderSizer.Add(gainSlider, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
freqLabel = wxStaticText(self, -1, "Frequency 0")
freqSlider = wxSlider(self, ID_FREQ_SLIDER0,
options.frequency[0] / 16000, 0, 20e3,
style = wxSL_HORIZONTAL | wxSL_AUTOTICKS)
freqSlider.SetSize((400, -1))
sliderSizer.Add(freqLabel, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
sliderSizer.Add(freqSlider, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
if len(options.frequency) > 1 :
# TX d'board 1
gainLabel = wxStaticText(self, -1, "PGA 1")
gainSlider = wxSlider(self, ID_GAIN_SLIDER1, self.pga,
self.pgaMin / self.pgaStep, self.pgaMax / self.pgaStep,
style = wxSL_HORIZONTAL | wxSL_AUTOTICKS)
gainSlider.SetSize((400, -1))
sliderSizer.Add(gainLabel, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
sliderSizer.Add(gainSlider, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
freqLabel = wxStaticText(self, -1, "Frequency 1")
freqSlider = wxSlider(self, ID_FREQ_SLIDER1,
options.frequency[1] / 16000, 0, 20e3,
style = wxSL_HORIZONTAL | wxSL_AUTOTICKS)
freqSlider.SetSize((400, -1))
sliderSizer.Add(freqLabel, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
sliderSizer.Add(freqSlider, 0,
wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 0)
mainSizer.Add(sliderSizer, 1, wxEXPAND, 0)
start = wxButton(self, ID_START, "Start")
stop = wxButton(self, ID_STOP, "Stop")
buttonSizer.Add(start, 1, wxALIGN_CENTER, 0)
buttonSizer.Add(stop, 1, wxALIGN_CENTER, 0)
mainSizer.Add(buttonSizer, 1, wxEXPAND, 0)
# GnuRadio
self.fg = gr.flow_graph()
if options.mode == 1 :
print "Source: real"
if (options.encoding == "s") :
print "Source encoding: short"
src = gr.file_source(gr.sizeof_short, options.filename[0], 1)
if (options.copy) :
print "Imag: copy"
imag = src
else :
print "Imag: null"
imag = gr.null_source(gr.sizeof_short)
interleaver = gr.interleave(gr.sizeof_short)
self.fg.connect(src, (interleaver, 0))
self.fg.connect(imag, (interleaver, 1))
tail = interleaver
elif (options.encoding == "f") :
print "Source encoding: float"
src = gr.file_source(gr.sizeof_gr_complex,
options.filename[0], 1)
tail = src
elif (options.mode == 2) :
print "Source: complex"
if len(options.frequency) == 1 :
if (options.encoding == "s") :
print "Source encoding: short"
src = gr.file_source(gr.sizeof_short,
options.filename[0], 1)
elif (options.encoding == "f") :
print "Source encoding: float"
src = gr.file_source(gr.sizeof_gr_complex,
options.filename[0], 1)
else :
parser.error("Invalid encoding type for complex data!")
tail = src
elif (len(options.frequency) == 2) :
src0 = gr.file_source(gr.sizeof_gr_complex,
options.filename[0], 1)
src1 = gr.file_source(gr.sizeof_gr_complex,
options.filename[1], 1)
interleaver = gr.interleave(gr.sizeof_gr_complex)
self.fg.connect(src0, (interleaver, 0))
self.fg.connect(src1, (interleaver, 1))
tail = interleaver
else :
parser.error(
"Invalid number of source (> 2) with complex input!")
else :
parser.error("Invalid mode!")
# Interpolation
dac_freq = options.clockrate
interp = int(dac_freq / options.samplingrate)
if interp == 0 :
parser.error("Invalid sampling rate!")
if options.mode == 2 :
print "Input sampling rate: %s complex samples/s" % \
num_to_str(options.samplingrate)
else :
print "Input sampling rate: %s samples/s" % \
num_to_str(options.samplingrate)
print "Interpolation rate: int(%s / %s) = %sx" % \
(num_to_str(dac_freq), num_to_str(options.samplingrate), interp)
if interp > 512 :
factor = gcd(dac_freq / 512, options.samplingrate)
num = int((dac_freq / 512) / factor)
den = int(options.samplingrate / factor)
print "Resampling by %i / %i" % (num, den)
resampler = blks.rational_resampler_ccc(self.fg, num, den)
self.fg.connect(tail, resampler)
tail = resampler
interp = 512
options.samplingrate = dac_freq / 512
# AGC
if options.agc :
agc = gr.agc_cc()
self.fg.connect(tail, agc)
tail = agc
# USRP
if options.usrp :
nchan = len(options.frequency)
if len(options.frequency) == 1 :
if options.mode == 1 :
mux = 0x00000098
elif options.mode == 2 :
mux = 0x00000098
else :
parser.error("Unsupported mode for USRP mux!")
elif len(options.frequency) == 2 :
if options.mode == 1 :
mux = 0x0000ba98
elif options.mode == 2 :
mux = 0x0000ba98
else :
parser.error("Unsupported mode for USRP mux!")
else :
parser.error("Invalid number of frequency [0..2]!")
# if options.tx == "A" :
# mux = 0x00000098
# else :
# mux = 0x00009800
print "Nb channels: ", nchan
print "Mux: 0x%x" % mux
if options.encoding == 's' :
dst = usrp.sink_s(0, interp, nchan, mux)
elif options.encoding == 'f' :
dst = usrp.sink_c(0, interp, nchan, mux)
else :
parser.error("Unsupported data encoding for USRP!")
dst.set_verbose(1)
for i in range(len(options.frequency)) :
if options.gain is None :
print "Setting gain to %f" % dst.pga_max()
dst.set_pga(i << 1, dst.pga_max())
else :
print "Setting gain to %f" % options.gain
dst.set_pga(i << 1, options.gain)
tune = false
for dboard in dst.db:
if (dboard[0].dbid() != -1):
device = dboard[0]
print "Tuning TX d'board %s to %sHz" % \
(device.side_and_name(),
num_to_str(options.frequency[i]))
device.lo_offset = 38e6
(min, max, offset) = device.freq_range()
print " Frequency"
print " Min: %sHz" % num_to_str(min)
print " Max: %sHz" % num_to_str(max)
print " Offset: %sHz" % num_to_str(offset)
#device.set_gain(device.gain_range()[1])
device.set_enable(True)
tune = \
dst.tune(device._which, device,
options.frequency[i] * 128e6 / dac_freq)
if tune:
print " Baseband frequency: %sHz" % \
num_to_str(tune.baseband_freq)
print " DXC frequency: %sHz" % \
num_to_str(tune.dxc_freq)
print " Residual Freqency: %sHz" % \
num_to_str(tune.residual_freq)
print " Inverted: ", \
tune.inverted
mux = usrp.determine_tx_mux_value(dst,
(device._which, 0))
dst.set_mux(mux)
break
else:
print " Failed!"
if not tune:
print " Failed!"
raise SystemExit
# int nunderruns ()
print "USRP"
print " Rx halfband: ", dst.has_rx_halfband()
print " Tx halfband: ", dst.has_tx_halfband()
print " Nb DDC: ", dst.nddc()
print " Nb DUC: ", dst.nduc()
#dst._write_9862(0, 14, 224)
print " DAC frequency: %s samples/s" % num_to_str(dst.dac_freq())
print " Fpga decimation rate: %s -> %s samples/s" % \
(num_to_str(dst.interp_rate()),
num_to_str(dac_freq / dst.interp_rate()))
print " Nb channels:",
if hasattr(dst, "nchannels()") :
print dst.nchannels()
else:
print "N/A"
print " Mux:",
if hasattr(dst, "mux()") :
print "0x%x" % dst.mux()
else :
print "N/A"
print " FPGA master clock frequency:",
if hasattr(dst, "fpga_master_clock_freq()") :
print "%sHz" % num_to_str(dst.fpga_master_clock_freq())
else :
print "N/A"
print " Converter rate:",
if hasattr(dst, "converter_rate()") :
print "%s" % num_to_str(dst.converter_rate())
else :
print "N/A"
print " DAC rate:",
if hasattr(dst, "dac_rate()") :
print "%s sample/s" % num_to_str(dst.dac_rate())
else :
print "N/A"
print " Interp rate: %sx" % num_to_str(dst.interp_rate())
print " DUC frequency 0: %sHz" % num_to_str(dst.tx_freq(0))
print " DUC frequency 1: %sHz" % num_to_str(dst.tx_freq(1))
print " Programmable Gain Amplifier 0: %s dB" % \
num_to_str(dst.pga(0))
print " Programmable Gain Amplifier 1: %s dB" % \
num_to_str(dst.pga(2))
else :
dst = gr.null_sink(gr.sizeof_gr_complex)
# AGC
if options.agc :
agc = gr.agc_cc()
self.fg.connect(tail, agc)
tail = agc
self.fg.connect(tail, dst)
# oscilloscope
if options.osc :
oscPanel = wxPanel(self, -1)
if (options.encoding == "s") :
converter = gr.interleaved_short_to_complex()
self.fg.connect(tail, converter)
signal = converter
elif (options.encoding == "f") :
signal = tail
else :
parser.error("Unsupported data encoding for oscilloscope!")
#block = scope_sink_f(fg, parent, title=label, sample_rate=input_rate)
#return (block, block.win)
oscWin = scopesink.scope_sink_c(self.fg, oscPanel, "Signal",
options.samplingrate)
self.fg.connect(signal, oscWin)
mainSizer.Add(oscPanel, 1, wxEXPAND)
# spectrometer
if options.spectrum :
ymin = 0
ymax = 160
fftPanel = wxPanel(self, -1)
if (options.encoding == "s") :
converter = gr.interleaved_short_to_complex()
self.fg.connect(tail, converter)
signal = converter
elif (options.encoding == "f") :
signal = tail
else :
parser.error("Unsupported data encoding for oscilloscope!")
fftWin = fftsink.fft_sink_c(self.fg, fftPanel,
title="Spectrum",
fft_size=2048,
sample_rate=options.samplingrate,
y_per_div=(ymax - ymin) / 8,
ref_level=ymax,
fft_rate=50,
average=True
)
self.fg.connect(signal, fftWin)
mainSizer.Add(fftPanel, 1, wxEXPAND)
# Events
EVT_MENU(self, ID_ABOUT, self.OnAbout)
EVT_MENU(self, ID_EXIT, self.TimeToQuit)
EVT_SLIDER(self, ID_GAIN_SLIDER0, self.slideEvent)
EVT_SLIDER(self, ID_FREQ_SLIDER0, self.slideEvent)
EVT_SLIDER(self, ID_GAIN_SLIDER1, self.slideEvent)
EVT_SLIDER(self, ID_FREQ_SLIDER1, self.slideEvent)
EVT_BUTTON(self, ID_START, self.onClick)
EVT_BUTTON(self, ID_STOP, self.onClick)
#Layout sizers
self.SetSizer(mainSizer)
self.SetAutoLayout(1)
mainSizer.Fit(self)
self.fg.start()
def __init__(self, frame, panel, vbox, argv):
MAX_CHANNELS = 7
stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B")
parser.add_option("-d","--debug", action="store_true", default=False)
parser.add_option("-e","--enable-fft", action="store_true", default=False,
help="enable spectrum plot (and use more CPU)")
parser.add_option("-f", "--freq", type="eng_float", default=None,
help="set Tx frequency to FREQ [required]", metavar="FREQ")
parser.add_option("-n", "--nchannels", type="int", default=2,
help="number of Tx channels [1,4]")
parser.add_option("-p", "--udp-port", type="int", default=32001,
help="initial UDP port number")
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.nchannels < 1 or options.nchannels > MAX_CHANNELS:
sys.stderr.write ("op25_tx: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS)
sys.exit(1)
if options.freq is None:
sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
# Set up constants and parameters
self.u = usrp.sink_c () # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
#print "mux = %#04x" % (m,)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.subdev.set_gain(self.subdev.gain_range()[0]) # set min Tx gain
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(options.freq),
eng_notation.num_to_str(freq_range[0]),
eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True) # enable transmitter
self.sum = gr.add_cc()
step = 25e3
offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step, -3 * step)
# Instantiate N TX channels
for i in range(options.nchannels):
t = tx_channel_usrp(options.udp_port + i, MAX_GAIN / options.nchannels, self.usrp_rate, offset[i])
self.connect (t, (self.sum, i))
self.connect (self.sum, self.u)
# plot an FFT to verify we are sending what we want
if options.enable_fft:
post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation",
fft_size=512, sample_rate=self.usrp_rate,
y_per_div=20, ref_level=40)
self.connect (self.sum, post_mod)
vbox.Add (post_mod.win, 1, wx.EXPAND)
if options.debug:
# self.debugger = tx_debug_gui.tx_debug_gui(self.subdev)
# self.debugger.Show(True)
print "attach pid %d" % os.getpid()
raw_input("press enter")
def __init__(self, frame, panel, vbox, argv):
MAX_CHANNELS = 7
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
parser.add_option("-d", "--debug", action="store_true", default=False)
parser.add_option("-e",
"--enable-fft",
action="store_true",
default=False,
help="enable spectrum plot (and use more CPU)")
parser.add_option("-f",
"--freq",
type="eng_float",
default=None,
help="set Tx frequency to FREQ [required]",
metavar="FREQ")
parser.add_option("-n",
"--nchannels",
type="int",
default=2,
help="number of Tx channels [1,4]")
parser.add_option("-p",
"--udp-port",
type="int",
default=32001,
help="initial UDP port number")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.nchannels < 1 or options.nchannels > MAX_CHANNELS:
sys.stderr.write(
"op25_tx: nchannels out of range. Must be in [1,%d]\n" %
MAX_CHANNELS)
sys.exit(1)
if options.freq is None:
sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
# Set up constants and parameters
self.u = usrp.sink_c() # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
#print "mux = %#04x" % (m,)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(), )
self.subdev.set_gain(self.subdev.gain_range()[0]) # set min Tx gain
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(
options.freq), eng_notation.num_to_str(
freq_range[0]), eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True) # enable transmitter
self.sum = gr.add_cc()
step = 25e3
offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step,
-3 * step)
# Instantiate N TX channels
for i in range(options.nchannels):
t = tx_channel_usrp(options.udp_port + i,
MAX_GAIN / options.nchannels, self.usrp_rate,
offset[i])
self.connect(t, (self.sum, i))
self.connect(self.sum, self.u)
# plot an FFT to verify we are sending what we want
if options.enable_fft:
post_mod = fftsink2.fft_sink_c(panel,
title="Post Modulation",
fft_size=512,
sample_rate=self.usrp_rate,
y_per_div=20,
ref_level=40)
self.connect(self.sum, post_mod)
vbox.Add(post_mod.win, 1, wx.EXPAND)
if options.debug:
# self.debugger = tx_debug_gui.tx_debug_gui(self.subdev)
# self.debugger.Show(True)
print "attach pid %d" % os.getpid()
raw_input("press enter")
def __init__(self, frame, panel, vbox, argv):
MAX_CHANNELS = 7
stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv)
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B")
parser.add_option("-e","--enable-fft", action="store_true", default=False,
help="enable spectrum plot (and use more CPU)")
parser.add_option("-f", "--freq", type="eng_float", default=None,
help="set Tx frequency to FREQ [required]", metavar="FREQ")
parser.add_option("-i","--file-input", action="store_true", default=False,
help="input from baseband-0.dat, baseband-1.dat ...")
parser.add_option("-g", "--audio-gain", type="eng_float", default=1.0,
help="input audio gain multiplier")
parser.add_option("-n", "--nchannels", type="int", default=2,
help="number of Tx channels [1,4]")
parser.add_option("-a", "--udp-addr", type="string", default="127.0.0.1",
help="UDP host IP address")
parser.add_option("-p", "--udp-port", type="int", default=0,
help="UDP port number")
parser.add_option("-r","--repeat", action="store_true", default=False,
help="continuously replay input file")
parser.add_option("-S", "--stretch", type="int", default=0,
help="elastic buffer trigger value")
parser.add_option("-v","--verbose", action="store_true", default=False,
help="print out stats")
parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp")
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.nchannels < 1 or options.nchannels > MAX_CHANNELS:
sys.stderr.write ("op25_tx: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS)
sys.exit(1)
if options.freq is None:
sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
# Set up constants and parameters
self.u = usrp.sink_c () # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 400
self.u.set_interp_rate(self.usrp_interp)
self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s
self.sw_interp = 10
self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
#print "mux = %#04x" % (m,)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s" % (self.subdev.side_and_name(),)
self.subdev.set_gain(self.subdev.gain_range()[0]) # set min Tx gain
if not self.set_freq(options.freq):
freq_range = self.subdev.freq_range()
print "Failed to set frequency to %s. Daughterboard supports %s to %s" % (
eng_notation.num_to_str(options.freq),
eng_notation.num_to_str(freq_range[0]),
eng_notation.num_to_str(freq_range[1]))
raise SystemExit
self.subdev.set_enable(True) # enable transmitter
# instantiate vocoders
self.vocoders = []
if options.file_input:
for i in range (options.nchannels):
t = gr.file_source(gr.sizeof_char, "baseband-%d.dat" % i, options.repeat)
self.vocoders.append(t)
elif options.udp_port > 0:
self.udp_sources = []
for i in range (options.nchannels):
t = gr.udp_source(1, options.udp_addr, options.udp_port + i, 216)
self.udp_sources.append(t)
arity = 2
t = gr.packed_to_unpacked_bb(arity, gr.GR_MSB_FIRST)
self.vocoders.append(t)
self.connect(self.udp_sources[i], self.vocoders[i])
else:
self.audio_amps = []
self.converters = []
input_audio_rate = 8000
self.audio_input = audio.source(input_audio_rate, options.audio_input)
for i in range (options.nchannels):
t = gr.multiply_const_ff(32767 * options.audio_gain)
self.audio_amps.append(t)
t = gr.float_to_short()
self.converters.append(t)
t = repeater.vocoder(True, # 0=Decode,True=Encode
options.verbose, # Verbose flag
options.stretch, # flex amount
"", # udp ip address
0, # udp port
False) # dump raw u vectors
self.vocoders.append(t)
self.connect((self.audio_input, i), self.audio_amps[i], self.converters[i], self.vocoders[i])
sum = gr.add_cc ()
# Instantiate N NBFM channels
step = 25e3
offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step, -3 * step)
for i in range (options.nchannels):
t = pipeline(self.vocoders[i], offset[i],
self.audio_rate, self.usrp_rate)
self.connect(t, (sum, i))
gain = gr.multiply_const_cc (4000.0 / options.nchannels)
# connect it all
self.connect (sum, gain)
self.connect (gain, self.u)
# plot an FFT to verify we are sending what we want
if options.enable_fft:
post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation",
fft_size=512, sample_rate=self.usrp_rate,
y_per_div=20, ref_level=40)
self.connect (sum, post_mod)
vbox.Add (post_mod.win, 1, wx.EXPAND)
def main():
#TX
which_usrp = 0
fpga = "gen2_reader.rbf"
freq = 915e6
rx_gain = 20
samp_freq = (64 / dec_rate) * 1e6
tx = usrp.sink_c(which_usrp,
fusb_block_size=1024,
fusb_nblocks=4,
fpga_filename=fpga)
tx.set_interp_rate(interp)
tx_subdev = (0, 0)
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev, freq)
if not t:
print "Couldn't set tx freq"
#End TX
#RX
rx = usrp.source_c(which_usrp,
dec_rate,
fusb_block_size=512,
fusb_nblocks=16,
fpga_filename=fpga)
rx_subdev_spec = (1, 0)
rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec))
rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec)
rx_subdev.set_gain(rx_gain)
rx_subdev.set_auto_tr(False)
rx_subdev.set_enable(True)
us_per_sample = 1 / (64.0 / dec_rate / sw_dec)
print "Sample Frequency: " + str(samp_freq) + " us Per Sample: " + str(
us_per_sample)
r = usrp.tune(rx, 0, rx_subdev, freq)
if not r:
print "Couldn't set rx freq"
#End RX
gen2_reader = rfid.gen2_reader(dec_rate * sw_dec * samples_per_pulse,
interp)
tb = my_top_block(rx, gen2_reader, tx)
tb.start()
log_file = open("log_out.log", "w")
while 1:
c = raw_input("'Q' to quit\n")
if c == "q":
break
if c == "A" or c == "a":
log_file.write("T,CMD,ERROR,BITS,SNR\n")
log = gen2_reader.get_log()
print "Log has %s Entries" % (str(log.count()))
i = log.count()
for k in range(0, i):
msg = log.delete_head_nowait()
print_log_msg(msg, log_file)
tb.stop()
log_file.close()
def __init__(self):
gr.top_block.__init__(self)
amplitude = 30000
filt_out = gr.file_sink(gr.sizeof_gr_complex, "./filt.out")
filt2_out = gr.file_sink(gr.sizeof_gr_complex, "./filt2.out")
ffilt_out = gr.file_sink(gr.sizeof_float, "./ffilt.out")
ffilt2_out = gr.file_sink(gr.sizeof_float, "./ffilt2.out")
interp_rate = 128
dec_rate = 8
sw_dec = 4
num_taps = int(64000 / ( (dec_rate * 4) * 256 )) #Filter matched to 1/4 of the 256 kHz tag cycle
taps = [complex(1,1)] * num_taps
matched_filt = gr.fir_filter_ccc(sw_dec, taps);
agc = gr.agc2_cc(0.3, 1e-3, 1, 1, 100)
to_mag = gr.complex_to_mag()
center = rfid.center_ff(4)
omega = 2
mu = 0.25
gain_mu = 0.25
gain_omega = .25 * gain_mu * gain_mu
omega_relative_limit = .05
mm = gr.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_relative_limit)
self.reader = rfid.reader_f(int(128e6/interp_rate));
tag_decoder = rfid.tag_decoder_f()
command_gate = rfid.command_gate_cc(12, 60, 64000000 / dec_rate / sw_dec)
to_complex = gr.float_to_complex()
amp = gr.multiply_const_ff(amplitude)
f_sink = gr.file_sink(gr.sizeof_gr_complex, 'f_sink.out');
f_sink2 = gr.file_sink(gr.sizeof_gr_complex, 'f_sink2.out');
#TX
freq = 915e6
rx_gain = 20
tx = usrp.sink_c(fusb_block_size = 1024, fusb_nblocks=8)
tx.set_interp_rate(interp_rate)
tx_subdev = (0,0)
tx.set_mux(usrp.determine_tx_mux_value(tx, tx_subdev))
subdev = usrp.selected_subdev(tx, tx_subdev)
subdev.set_enable(True)
subdev.set_gain(subdev.gain_range()[2])
t = tx.tune(subdev.which(), subdev, freq)
if not t:
print "Couldn't set tx freq"
#End TX
#RX
rx = usrp.source_c(0, dec_rate, fusb_block_size = 512 * 4, fusb_nblocks = 16)
rx_subdev_spec = (1,0)
rx.set_mux(usrp.determine_rx_mux_value(rx, rx_subdev_spec))
rx_subdev = usrp.selected_subdev(rx, rx_subdev_spec)
rx_subdev.set_gain(rx_gain)
rx_subdev.set_auto_tr(False)
rx_subdev.set_enable(True)
r = usrp.tune(rx, 0, rx_subdev, freq)
self.rx = rx
if not r:
print "Couldn't set rx freq"
#End RX
command_gate.set_ctrl_out(self.reader.ctrl_q())
tag_decoder.set_ctrl_out(self.reader.ctrl_q())
agc2 = gr.agc2_ff(0.3, 1e-3, 1, 1, 100)
#########Build Graph
self.connect(rx, matched_filt)
self.connect(matched_filt, command_gate)
self.connect(command_gate, agc)
self.connect(agc, to_mag)
self.connect(to_mag, center, agc2, mm, tag_decoder)
self.connect(tag_decoder, self.reader, amp, to_complex, tx);
#################
self.connect(matched_filt, filt_out)
def __init__(self, frame, panel, vbox, argv):
stdgui.gui_flow_graph.__init__ (self, frame, panel, vbox, argv)
parser = OptionParser (option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B")
parser.add_option("-f", "--freq", type="eng_float", default=None,
help="set Tx frequency to FREQ [required]", metavar="FREQ")
parser.add_option("","--debug", action="store_true", default=False,
help="Launch Tx debugger")
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
sys.exit(1)
if options.freq is None:
sys.stderr.write("usrp_tx_video.py: must specify frequency with -f FREQ\n")
parser.print_help()
sys.exit(1)
# ----------------------------------------------------------------
self.u = usrp.sink_c () # the USRP sink (consumes samples)
self.dac_rate = self.u.dac_rate() # 128 MS/s
self.usrp_interp = 128
self.usrp_rate = self.dac_rate / self.usrp_interp
self.u.set_interp_rate(self.usrp_interp)
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)
self.u.set_mux(m)
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using TX d'board %s with rate %ld" % (self.subdev.side_and_name(), self.usrp_rate)
self.subdev.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
self.u.tune(self.subdev._which, self.subdev, options.freq)
self.subdev.set_enable(True) # enable transmitter
t = pipeline(self, options.freq, self.usrp_rate)
gain = gr.multiply_const_cc (32000.0)
# connect it all
self.connect (t, gain)
self.connect (gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
post_mod_fft = fftsink.fft_sink_c(self, panel, title="Signal in frequency domain",
fft_size=64, sample_rate=self.usrp_rate,
y_per_div=20, ref_level=40)
#post_mod_oscope = scopesink.scope_sink_c(self, panel, sample_rate=self.usrp_rate,
# title="Signal in time domain", v_scale = 1,
# t_scale=0.0001)
self.connect (t, post_mod_fft)
#self.connect (t, post_mod_oscope)
vbox.Add (post_mod_fft.win, 1, wx.EXPAND)
#vbox.Add (post_mod_oscope.win, 1, wx.EXPAND)
if options.debug:
self.debugger = tx_debug_gui.tx_debug_gui(self.subdev)
self.debugger.Show(True)
