From 28e086141aead2e43f958f0ae14d58cac557fa2d Mon Sep 17 00:00:00 2001
From: trondeau <trondeau@221aa14e-8319-0410-a670-987f0aec2ac5>
Date: Wed, 7 Mar 2007 04:31:19 +0000
Subject: merged trondeau/digital-wip2 r4193:4730 into trunk - improves digital
receiver and fixes ticket:72
git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@4731 221aa14e-8319-0410-a670-987f0aec2ac5
---
.../python/digital/benchmark_loopback.py | 185 +++++++++++++
gnuradio-examples/python/digital/receive_path.py | 34 +--
.../python/digital/receive_path_lb.py | 136 ++++++++++
.../python/digital/transmit_path_lb.py | 117 +++++++++
gnuradio-examples/python/hier/Makefile.am | 1 +
gnuradio-examples/python/hier/digital/Makefile.am | 35 +++
gnuradio-examples/python/hier/digital/README | 77 ++++++
.../python/hier/digital/benchmark_loopback.py | 206 +++++++++++++++
.../python/hier/digital/benchmark_rx.py | 119 +++++++++
.../python/hier/digital/benchmark_tx.py | 126 +++++++++
.../python/hier/digital/fusb_options.py | 31 +++
.../python/hier/digital/pick_bitrate.py | 143 ++++++++++
.../python/hier/digital/receive_path.py | 264 +++++++++++++++++++
.../python/hier/digital/receive_path_lb.py | 140 ++++++++++
gnuradio-examples/python/hier/digital/rx_voice.py | 136 ++++++++++
.../python/hier/digital/transmit_path.py | 239 +++++++++++++++++
.../python/hier/digital/transmit_path_lb.py | 123 +++++++++
gnuradio-examples/python/hier/digital/tunnel.py | 290 +++++++++++++++++++++
gnuradio-examples/python/hier/digital/tx_voice.py | 149 +++++++++++
gnuradio-examples/python/hier/usrp/Makefile.am | 3 +-
gnuradio-examples/python/hier/usrp/usrp_siggen.py | 145 +++++++++++
21 files changed, 2682 insertions(+), 17 deletions(-)
create mode 100755 gnuradio-examples/python/digital/benchmark_loopback.py
create mode 100644 gnuradio-examples/python/digital/receive_path_lb.py
create mode 100644 gnuradio-examples/python/digital/transmit_path_lb.py
create mode 100644 gnuradio-examples/python/hier/digital/Makefile.am
create mode 100644 gnuradio-examples/python/hier/digital/README
create mode 100755 gnuradio-examples/python/hier/digital/benchmark_loopback.py
create mode 100755 gnuradio-examples/python/hier/digital/benchmark_rx.py
create mode 100755 gnuradio-examples/python/hier/digital/benchmark_tx.py
create mode 100644 gnuradio-examples/python/hier/digital/fusb_options.py
create mode 100644 gnuradio-examples/python/hier/digital/pick_bitrate.py
create mode 100644 gnuradio-examples/python/hier/digital/receive_path.py
create mode 100644 gnuradio-examples/python/hier/digital/receive_path_lb.py
create mode 100755 gnuradio-examples/python/hier/digital/rx_voice.py
create mode 100644 gnuradio-examples/python/hier/digital/transmit_path.py
create mode 100644 gnuradio-examples/python/hier/digital/transmit_path_lb.py
create mode 100755 gnuradio-examples/python/hier/digital/tunnel.py
create mode 100755 gnuradio-examples/python/hier/digital/tx_voice.py
create mode 100755 gnuradio-examples/python/hier/usrp/usrp_siggen.py
(limited to 'gnuradio-examples/python')
diff --git a/gnuradio-examples/python/digital/benchmark_loopback.py b/gnuradio-examples/python/digital/benchmark_loopback.py
new file mode 100755
index 0000000000..d036f63aab
--- /dev/null
+++ b/gnuradio-examples/python/digital/benchmark_loopback.py
@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+#!/usr/bin/env python
+#
+# Copyright 2005, 2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+import random, time, struct, sys, math
+
+# from current dir
+from transmit_path_lb import transmit_path
+from receive_path_lb import receive_path
+import fusb_options
+
+class awgn_channel(gr.hier_block):
+ def __init__(self, fg, sample_rate, noise_voltage, frequency_offset, seed=False):
+ self.input = gr.add_const_cc(0) # dummy input device
+
+ # Create the Gaussian noise source
+ if not seed:
+ self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage)
+ else:
+ rseed = int(time.time())
+ self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage, rseed)
+
+ self.adder = gr.add_cc()
+
+ # Create the frequency offset
+ self.offset = gr.sig_source_c(1, gr.GR_SIN_WAVE,
+ frequency_offset, 1.0, 0.0)
+ self.mixer = gr.multiply_cc()
+
+ # Connect the components
+ fg.connect(self.input, (self.mixer, 0))
+ fg.connect(self.offset, (self.mixer, 1))
+ fg.connect(self.mixer, (self.adder, 0))
+ fg.connect(self.noise, (self.adder, 1))
+
+ gr.hier_block.__init__(self, fg, self.input, self.adder)
+
+class my_graph(gr.flow_graph):
+ def __init__(self, mod_class, demod_class, rx_callback, options):
+ gr.flow_graph.__init__(self)
+
+ channelon = True;
+
+ SNR = 10.0**(options.snr/10.0)
+ frequency_offset = options.frequency_offset
+
+ power_in_signal = abs(options.tx_amplitude)**2
+ noise_power = power_in_signal/SNR
+ noise_voltage = math.sqrt(noise_power)
+
+ self.txpath = transmit_path(self, mod_class, options)
+ self.throttle = gr.throttle(gr.sizeof_gr_complex, options.sample_rate)
+ self.rxpath = receive_path(self, demod_class, rx_callback, options)
+
+ if channelon:
+ self.channel = awgn_channel(self, options.sample_rate, noise_voltage, frequency_offset, options.seed)
+
+ # Connect components
+ self.connect(self.txpath, self.throttle, self.channel, self.rxpath)
+ else:
+ # Connect components
+ self.connect(self.txpath, self.throttle, self.rxpath)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+def main():
+
+ global n_rcvd, n_right
+
+ n_rcvd = 0
+ n_right = 0
+
+ def rx_callback(ok, payload):
+ global n_rcvd, n_right
+ (pktno,) = struct.unpack('!H', payload[0:2])
+ n_rcvd += 1
+ if ok:
+ n_right += 1
+
+ print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
+ ok, pktno, n_rcvd, n_right)
+
+ def send_pkt(payload='', eof=False):
+ return fg.txpath.send_pkt(payload, eof)
+
+
+ mods = modulation_utils.type_1_mods()
+ demods = modulation_utils.type_1_demods()
+
+ parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+ channel_grp = parser.add_option_group("Channel")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
+ default='dbpsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(mods.keys()),))
+
+ parser.add_option("-s", "--size", type="eng_float", default=1500,
+ help="set packet size [default=%default]")
+ parser.add_option("-M", "--megabytes", type="eng_float", default=1.0,
+ help="set megabytes to transmit [default=%default]")
+ parser.add_option("","--discontinuous", action="store_true", default=False,
+ help="enable discontinous transmission (bursts of 5 packets)")
+
+ channel_grp.add_option("", "--sample-rate", type="eng_float", default=1e5,
+ help="set speed of channel/simulation rate to RATE [default=%default]")
+ channel_grp.add_option("", "--snr", type="eng_float", default=30,
+ help="set the SNR of the channel in dB [default=%default]")
+ channel_grp.add_option("", "--frequency-offset", type="eng_float", default=0,
+ help="set frequency offset introduced by channel [default=%default]")
+ channel_grp.add_option("", "--seed", action="store_true", default=False,
+ help="use a random seed for AWGN noise [default=%default]")
+
+ transmit_path.add_options(parser, expert_grp)
+ receive_path.add_options(parser, expert_grp)
+
+ for mod in mods.values():
+ mod.add_options(expert_grp)
+ for demod in demods.values():
+ demod.add_options(expert_grp)
+
+ (options, args) = parser.parse_args ()
+
+ if len(args) != 0:
+ parser.print_help()
+ sys.exit(1)
+
+ r = gr.enable_realtime_scheduling()
+ if r != gr.RT_OK:
+ print "Warning: failed to enable realtime scheduling"
+
+ # Create an instance of a hierarchical block
+ fg = my_graph(mods[options.modulation], demods[options.modulation], rx_callback, options)
+ fg.start()
+
+ # generate and send packets
+ nbytes = int(1e6 * options.megabytes)
+ n = 0
+ pktno = 0
+ pkt_size = int(options.size)
+
+ while n < nbytes:
+ send_pkt(struct.pack('!H', pktno) + (pkt_size - 2) * chr(pktno & 0xff))
+ n += pkt_size
+ if options.discontinuous and pktno % 5 == 4:
+ time.sleep(1)
+ pktno += 1
+
+ send_pkt(eof=True)
+
+ fg.wait()
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/digital/receive_path.py b/gnuradio-examples/python/digital/receive_path.py
index 9d55c88ddb..03e623f9fd 100644
--- a/gnuradio-examples/python/digital/receive_path.py
+++ b/gnuradio-examples/python/digital/receive_path.py
@@ -57,7 +57,22 @@ class receive_path(gr.hier_block):
# Set up USRP source; also adjusts decim, samples_per_symbol, and bitrate
self._setup_usrp_source()
-
+
+ g = self.subdev.gain_range()
+ if options.show_rx_gain_range:
+ print "Rx Gain Range: minimum = %g, maximum = %g, step size = %g" \
+ % (g[0], g[1], g[2])
+
+ self.set_gain(options.rx_gain)
+
+ self.set_auto_tr(True) # enable Auto Transmit/Receive switching
+
+ # Set RF frequency
+ ok = self.set_freq(self._rx_freq)
+ if not ok:
+ print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(self._rx_freq))
+ raise ValueError, eng_notation.num_to_str(self._rx_freq)
+
# copy the final answers back into options for use by demodulator
options.samples_per_symbol = self._samples_per_symbol
options.bitrate = self._bitrate
@@ -71,7 +86,7 @@ class receive_path(gr.hier_block):
chan_coeffs = gr.firdes.low_pass (1.0, # gain
sw_decim * self._samples_per_symbol, # sampling rate
1.0, # midpoint of trans. band
- 0.1, # width of trans. band
+ 0.5, # width of trans. band
gr.firdes.WIN_HANN) # filter type
# Decimating channel filter
@@ -86,21 +101,7 @@ class receive_path(gr.hier_block):
access_code=None,
callback=self._rx_callback,
threshold=-1)
-
- ok = self.set_freq(self._rx_freq)
- if not ok:
- print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(self._rx_freq))
- raise ValueError, eng_notation.num_to_str(self._rx_freq)
- g = self.subdev.gain_range()
- if options.show_rx_gain_range:
- print "Rx Gain Range: minimum = %g, maximum = %g, step size = %g" \
- % (g[0], g[1], g[2])
-
- self.set_gain(options.rx_gain)
-
- self.set_auto_tr(True) # enable Auto Transmit/Receive switching
-
# Carrier Sensing Blocks
alpha = 0.001
thresh = 30 # in dB, will have to adjust
@@ -228,6 +229,7 @@ class receive_path(gr.hier_block):
"""
Prints information about the receive path
"""
+ print "\nReceive Path:"
print "Using RX d'board %s" % (self.subdev.side_and_name(),)
print "Rx gain: %g" % (self.gain,)
print "modulation: %s" % (self._demod_class.__name__)
diff --git a/gnuradio-examples/python/digital/receive_path_lb.py b/gnuradio-examples/python/digital/receive_path_lb.py
new file mode 100644
index 0000000000..2bfdd72d44
--- /dev/null
+++ b/gnuradio-examples/python/digital/receive_path_lb.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, blks
+from gnuradio import eng_notation
+import copy
+import sys
+
+# /////////////////////////////////////////////////////////////////////////////
+# receive path
+# /////////////////////////////////////////////////////////////////////////////
+
+class receive_path(gr.hier_block):
+ def __init__(self, fg, demod_class, rx_callback, options):
+
+ options = copy.copy(options) # make a copy so we can destructively modify
+
+ self._verbose = options.verbose
+ self._bitrate = options.bitrate # desired bit rate
+ self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
+
+ self._rx_callback = rx_callback # this callback is fired when there's a packet available
+ self._demod_class = demod_class # the demodulator_class we're using
+
+ # Get demod_kwargs
+ demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
+
+ # Design filter to get actual channel we want
+ sw_decim = 1
+ chan_coeffs = gr.firdes.low_pass (1.0, # gain
+ sw_decim * self._samples_per_symbol, # sampling rate
+ 1.0, # midpoint of trans. band
+ 0.5, # width of trans. band
+ gr.firdes.WIN_HANN) # filter type
+ self.channel_filter = gr.fft_filter_ccc(sw_decim, chan_coeffs)
+
+ # receiver
+ self.packet_receiver = \
+ blks.demod_pkts(fg,
+ self._demod_class(fg, **demod_kwargs),
+ access_code=None,
+ callback=self._rx_callback,
+ threshold=-1)
+
+ # Carrier Sensing Blocks
+ alpha = 0.001
+ thresh = 30 # in dB, will have to adjust
+ self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
+
+ # Display some information about the setup
+ if self._verbose:
+ self._print_verbage()
+
+ # connect the channel input filter to the carrier power detector
+ fg.connect(self.channel_filter, self.probe)
+
+ # connect channel filter to the packet receiver
+ fg.connect(self.channel_filter, self.packet_receiver)
+
+ gr.hier_block.__init__(self, fg, self.channel_filter, None)
+
+ def bitrate(self):
+ return self._bitrate
+
+ def samples_per_symbol(self):
+ return self._samples_per_symbol
+
+ def carrier_sensed(self):
+ """
+ Return True if we think carrier is present.
+ """
+ #return self.probe.level() > X
+ return self.probe.unmuted()
+
+ def carrier_threshold(self):
+ """
+ Return current setting in dB.
+ """
+ return self.probe.threshold()
+
+ def set_carrier_threshold(self, threshold_in_db):
+ """
+ Set carrier threshold.
+
+ @param threshold_in_db: set detection threshold
+ @type threshold_in_db: float (dB)
+ """
+ self.probe.set_threshold(threshold_in_db)
+
+
+ def add_options(normal, expert):
+ """
+ Adds receiver-specific options to the Options Parser
+ """
+ if not normal.has_option("--bitrate"):
+ normal.add_option("-r", "--bitrate", type="eng_float", default=100e3,
+ help="specify bitrate [default=%default].")
+ normal.add_option("", "--show-rx-gain-range", action="store_true", default=False,
+ help="print min and max Rx gain available on selected daughterboard")
+ normal.add_option("-v", "--verbose", action="store_true", default=False)
+ expert.add_option("-S", "--samples-per-symbol", type="int", default=2,
+ help="set samples/symbol [default=%default]")
+ expert.add_option("", "--log", action="store_true", default=False,
+ help="Log all parts of flow graph to files (CAUTION: lots of data)")
+
+ # Make a static method to call before instantiation
+ add_options = staticmethod(add_options)
+
+
+ def _print_verbage(self):
+ """
+ Prints information about the receive path
+ """
+ print "\nReceive Path:"
+ print "modulation: %s" % (self._demod_class.__name__)
+ print "bitrate: %sb/s" % (eng_notation.num_to_str(self._bitrate))
+ print "samples/symbol: %3d" % (self._samples_per_symbol)
diff --git a/gnuradio-examples/python/digital/transmit_path_lb.py b/gnuradio-examples/python/digital/transmit_path_lb.py
new file mode 100644
index 0000000000..cd2c871d47
--- /dev/null
+++ b/gnuradio-examples/python/digital/transmit_path_lb.py
@@ -0,0 +1,117 @@
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, blks
+from gnuradio import eng_notation
+
+import copy
+import sys
+
+# /////////////////////////////////////////////////////////////////////////////
+# transmit path
+# /////////////////////////////////////////////////////////////////////////////
+
+class transmit_path(gr.hier_block):
+ def __init__(self, fg, modulator_class, options):
+ '''
+ See below for what options should hold
+ '''
+
+ options = copy.copy(options) # make a copy so we can destructively modify
+
+ self._verbose = options.verbose
+ self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP
+ self._bitrate = options.bitrate # desired bit rate
+ self._samples_per_symbol = options.samples_per_symbol # desired samples/baud
+
+ self._modulator_class = modulator_class # the modulator_class we are using
+
+ # Get mod_kwargs
+ mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)
+
+ # transmitter
+ self.packet_transmitter = \
+ blks.mod_pkts(fg,
+ self._modulator_class(fg, **mod_kwargs),
+ access_code=None,
+ msgq_limit=4,
+ pad_for_usrp=True)
+
+ self.amp = gr.multiply_const_cc(1)
+ self.set_tx_amplitude(self._tx_amplitude)
+
+ # Display some information about the setup
+ if self._verbose:
+ self._print_verbage()
+
+ # Connect components in the flowgraph
+ fg.connect(self.packet_transmitter, self.amp)
+
+ gr.hier_block.__init__(self, fg, None, self.amp)
+
+ def set_tx_amplitude(self, ampl):
+ """
+ Sets the transmit amplitude sent to the USRP
+ @param: ampl 0 <= ampl < 32768. Try 8000
+ """
+ self._tx_amplitude = max(0.0, min(ampl, 32767.0))
+ self.amp.set_k(self._tx_amplitude)
+
+ def send_pkt(self, payload='', eof=False):
+ """
+ Calls the transmitter method to send a packet
+ """
+ return self.packet_transmitter.send_pkt(payload, eof)
+
+ def bitrate(self):
+ return self._bitrate
+
+ def samples_per_symbol(self):
+ return self._samples_per_symbol
+
+ def add_options(normal, expert):
+ """
+ Adds transmitter-specific options to the Options Parser
+ """
+ if not normal.has_option('--bitrate'):
+ normal.add_option("-r", "--bitrate", type="eng_float", default=100e3,
+ help="specify bitrate [default=%default].")
+ normal.add_option("", "--tx-amplitude", type="eng_float", default=12000, metavar="AMPL",
+ help="set transmitter digital amplitude: 0 <= AMPL < 32768 [default=%default]")
+ normal.add_option("-v", "--verbose", action="store_true", default=False)
+
+ expert.add_option("-S", "--samples-per-symbol", type="int", default=2,
+ help="set samples/symbol [default=%default]")
+ expert.add_option("", "--log", action="store_true", default=False,
+ help="Log all parts of flow graph to file (CAUTION: lots of data)")
+
+ # Make a static method to call before instantiation
+ add_options = staticmethod(add_options)
+
+ def _print_verbage(self):
+ """
+ Prints information about the transmit path
+ """
+ print "Tx amplitude %s" % (self._tx_amplitude)
+ print "modulation: %s" % (self._modulator_class.__name__)
+ print "bitrate: %sb/s" % (eng_notation.num_to_str(self._bitrate))
+ print "samples/symbol: %3d" % (self._samples_per_symbol)
+
diff --git a/gnuradio-examples/python/hier/Makefile.am b/gnuradio-examples/python/hier/Makefile.am
index e58b361224..f9931b3e95 100644
--- a/gnuradio-examples/python/hier/Makefile.am
+++ b/gnuradio-examples/python/hier/Makefile.am
@@ -21,6 +21,7 @@
SUBDIRS = \
audio \
+ digital \
ofdm \
networking \
sounder \
diff --git a/gnuradio-examples/python/hier/digital/Makefile.am b/gnuradio-examples/python/hier/digital/Makefile.am
new file mode 100644
index 0000000000..9cdbc71214
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/Makefile.am
@@ -0,0 +1,35 @@
+#
+# Copyright 2004 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+EXTRA_DIST = \
+ README \
+ benchmark_loopback.py \
+ benchmark_rx.py \
+ benchmark_tx.py \
+ fusb_options.py \
+ pick_bitrate.py \
+ receive_path.py \
+ receive_path_lb.py \
+ rx_voice.py \
+ transmit_path.py \
+ transmit_path_lb.py \
+ tunnel.py \
+ tx_voice.py
diff --git a/gnuradio-examples/python/hier/digital/README b/gnuradio-examples/python/hier/digital/README
new file mode 100644
index 0000000000..9d8a404976
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/README
@@ -0,0 +1,77 @@
+Quick overview of what's here:
+
+* benchmark_tx.py: generates packets of the size you
+specify and sends them across the air using the USRP. Known to work
+well using the USRP with the RFX transceiver daughterboards.
+You can specify the bitrate to use with the -r <bitrate> command line
+parameter. The default is 500k. Some machines will do 1M or more.
+You can select the modulation to use with the -m <modulation> command
+line argument. The legal values for <modulation> are gmsk, dbpsk and dqpsk.
+
+* benchmark_rx.py: the receiver half of benchmark_tx.py.
+Command line arguments are pretty much the same as rx. Works well
+with a USRP and RFX transceiver daughterboards. Will also work
+with TVRX daugherboard, but you'll need to fiddle with the gain. See
+below. Prints a summary of each packet received and keeps a running
+total of packets received, and how many of them were error free.
+There are two levels of error reporting going on. If the access code
+(PN code) and header of a packet were properly detected, then you'll
+get an output line. If the CRC32 of the payload was correct you get
+"ok = True", else "ok = False". The "pktno" is extracted from the
+received packet. If there are skipped numbers, you're missing some
+packets. Be sure you've got a suitable antenna connected to the TX/RX
+port on each board. For the RFX-400, "70 cm" / 420 MHz antennas for ham
+handi-talkies work great. These are available at ham radio supplies,
+etc. The boards need to be at least 3m apart. You can also try
+experimenting with the rx gain (-g <gain> command line option).
+
+Generally speaking, I start the rx first on one machine, and then fire
+up the tx on the other machine. The tx also supports a discontinous
+transmission mode where it sends bursts of 5 packets and then waits 1
+second. This is useful for ensuring that all the receiver control
+loops lock up fast enough.
+
+* tunnel.py: This program provides a framework for building your own
+MACs. It creates a "TAP" interface in the kernel, typically gr0,
+and sends and receives ethernet frames through it. See
+/usr/src/linux/Documentation/networking/tuntap.txt and/or Google for
+"universal tun tap". The Linux 2.6 kernel includes the tun module, you
+don't have to build it. You may have to "modprobe tun" if it's not
+loaded by default. If /dev/net/tun doesn't exist, try "modprobe tun".
+
+To run this program you'll need to be root or running with the
+appropriate capability to open the tun interface. You'll need to fire
+up two copies on different machines. Once each is running you'll need
+to ifconfig the gr0 interface to set the IP address.
+
+This will allow two machines to talk, but anything beyond the two
+machines depends on your networking setup. Left as an exercise...
+
+On machine A:
+
+ $ su
+ # ./tunnel.py --freq 423.0M --bitrate 500k
+ # # in another window on A, also as root...
+ # ifconfig gr0 192.168.200.1
+
+
+On machine B:
+
+ $ su
+ # ./tunnel.py --freq 423.0M --bitrate 500k
+ # # in another window on B, also as root...
+ # ifconfig gr0 192.168.200.2
+
+Now, on machine A you shold be able to ping machine B:
+
+ $ ping 192.168.200.2
+
+and you should see some output for each packet in the
+tunnel.py window if you used the -v option.
+
+Likewise, on machine B:
+
+ $ ping 192.168.200.1
+
+This now uses a carrier sense MAC, so you should be able to ssh
+between the machines, web browse, etc.
diff --git a/gnuradio-examples/python/hier/digital/benchmark_loopback.py b/gnuradio-examples/python/hier/digital/benchmark_loopback.py
new file mode 100755
index 0000000000..92a7bb072b
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/benchmark_loopback.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+#!/usr/bin/env python
+#
+# Copyright 2005, 2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+import random, time, struct, sys, math
+
+# from current dir
+from transmit_path_lb import transmit_path
+from receive_path_lb import receive_path
+import fusb_options
+
+class awgn_channel(gr.hier_block2):
+ def __init__(self, sample_rate, noise_voltage, frequency_offset, seed=False):
+ gr.hier_block2.__init__(self, "awgn_channel",
+ gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+ gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+ # Create the Gaussian noise source
+ if not seed:
+ self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage)
+ else:
+ rseed = int(time.time())
+ self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage, rseed)
+ self.define_component("noise", self.noise)
+ self.define_component("adder", gr.add_cc())
+
+ # Create the frequency offset
+ self.define_component("offset", gr.sig_source_c((sample_rate*1.0), gr.GR_SIN_WAVE,
+ frequency_offset, 1.0, 0.0))
+ self.define_component("mixer", gr.multiply_cc())
+
+ # Connect the components
+ self.connect("self", 0, "mixer", 0)
+ self.connect("offset", 0, "mixer", 1)
+ self.connect("mixer", 0, "adder", 0)
+ self.connect("noise", 0, "adder", 1)
+ self.connect("adder", 0, "self", 0)
+
+
+class my_graph(gr.hier_block2):
+ def __init__(self, mod_class, demod_class, rx_callback, options):
+ gr.hier_block2.__init__(self, "my_graph",
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+
+ channelon = True;
+
+ SNR = 10.0**(options.snr/10.0)
+ frequency_offset = options.frequency_offset
+
+ power_in_signal = abs(options.tx_amplitude)**2
+ noise_power = power_in_signal/SNR
+ noise_voltage = math.sqrt(noise_power)
+
+ self.txpath = transmit_path(mod_class, options)
+ self.throttle = gr.throttle(gr.sizeof_gr_complex, options.sample_rate)
+ self.rxpath = receive_path(demod_class, rx_callback, options)
+
+ if channelon:
+ self.channel = awgn_channel(options.sample_rate, noise_voltage, frequency_offset, options.seed)
+
+ # Define the components
+ self.define_component("txpath", self.txpath)
+ self.define_component("throttle", self.throttle)
+ self.define_component("channel", self.channel)
+ self.define_component("rxpath", self.rxpath)
+
+ # Connect components
+ self.connect("txpath", 0, "throttle", 0)
+ self.connect("throttle", 0, "channel", 0)
+ self.connect("channel", 0, "rxpath", 0)
+ else:
+ # Define the components
+ self.define_component("txpath", self.txpath)
+ self.define_component("throttle", self.throttle)
+ self.define_component("rxpath", self.rxpath)
+
+ # Connect components
+ self.connect("txpath", 0, "throttle", 0)
+ self.connect("throttle", 0, "rxpath", 0)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+def main():
+
+ global n_rcvd, n_right
+
+ n_rcvd = 0
+ n_right = 0
+
+ def rx_callback(ok, payload):
+ global n_rcvd, n_right
+ (pktno,) = struct.unpack('!H', payload[0:2])
+ n_rcvd += 1
+ if ok:
+ n_right += 1
+
+ print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
+ ok, pktno, n_rcvd, n_right)
+
+ def send_pkt(payload='', eof=False):
+ return top_block.txpath.send_pkt(payload, eof)
+
+
+ mods = modulation_utils.type_1_mods()
+ demods = modulation_utils.type_1_demods()
+
+ parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+ channel_grp = parser.add_option_group("Channel")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
+ default='dbpsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(mods.keys()),))
+
+ parser.add_option("-s", "--size", type="eng_float", default=1500,
+ help="set packet size [default=%default]")
+ parser.add_option("-M", "--megabytes", type="eng_float", default=1.0,
+ help="set megabytes to transmit [default=%default]")
+ parser.add_option("","--discontinuous", action="store_true", default=False,
+ help="enable discontinous transmission (bursts of 5 packets)")
+
+ channel_grp.add_option("", "--sample-rate", type="eng_float", default=1e5,
+ help="set speed of channel/simulation rate to RATE [default=%default]")
+ channel_grp.add_option("", "--snr", type="eng_float", default=30,
+ help="set the SNR of the channel in dB [default=%default]")
+ channel_grp.add_option("", "--frequency-offset", type="eng_float", default=0,
+ help="set frequency offset introduced by channel [default=%default]")
+ channel_grp.add_option("", "--seed", action="store_true", default=False,
+ help="use a random seed for AWGN noise [default=%default]")
+
+ transmit_path.add_options(parser, expert_grp)
+ receive_path.add_options(parser, expert_grp)
+
+ for mod in mods.values():
+ mod.add_options(expert_grp)
+ for demod in demods.values():
+ demod.add_options(expert_grp)
+
+ (options, args) = parser.parse_args ()
+
+ if len(args) != 0:
+ parser.print_help()
+ sys.exit(1)
+
+ r = gr.enable_realtime_scheduling()
+ if r != gr.RT_OK:
+ print "Warning: failed to enable realtime scheduling"
+
+ # Create an instance of a hierarchical block
+ top_block = my_graph(mods[options.modulation], demods[options.modulation], rx_callback, options)
+
+ # Create an instance of a runtime, passing it the top block
+ runtime = gr.runtime(top_block)
+ runtime.start()
+
+ # generate and send packets
+ nbytes = int(1e6 * options.megabytes)
+ n = 0
+ pktno = 0
+ pkt_size = int(options.size)
+
+ while n < nbytes:
+ send_pkt(struct.pack('!H', pktno) + (pkt_size - 2) * chr(pktno & 0xff))
+ n += pkt_size
+ if options.discontinuous and pktno % 5 == 4:
+ time.sleep(1)
+ pktno += 1
+
+ send_pkt(eof=True)
+
+ runtime.wait()
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/hier/digital/benchmark_rx.py b/gnuradio-examples/python/hier/digital/benchmark_rx.py
new file mode 100755
index 0000000000..f65a634a32
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/benchmark_rx.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import usrp
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+import random
+import struct
+import sys
+
+# from current dir
+from receive_path import receive_path
+import fusb_options
+
+#import os
+#print os.getpid()
+#raw_input('Attach and press enter: ')
+
+
+class my_graph(gr.hier_block2):
+ def __init__(self, demod_class, rx_callback, options):
+ gr.hier_block2.__init__(self, "my_graph",
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+ self.rxpath = receive_path(demod_class, rx_callback, options)
+ self.define_component("rxpath", self.rxpath)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+global n_rcvd, n_right
+
+def main():
+ global n_rcvd, n_right
+
+ n_rcvd = 0
+ n_right = 0
+
+ def rx_callback(ok, payload):
+ global n_rcvd, n_right
+ (pktno,) = struct.unpack('!H', payload[0:2])
+ n_rcvd += 1
+ if ok:
+ n_right += 1
+
+ print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
+ ok, pktno, n_rcvd, n_right)
+
+
+ demods = modulation_utils.type_1_demods()
+
+ # Create Options Parser:
+ parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(),
+ default='gmsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(demods.keys()),))
+
+ receive_path.add_options(parser, expert_grp)
+
+ for mod in demods.values():
+ mod.add_options(expert_grp)
+
+ fusb_options.add_options(expert_grp)
+ (options, args) = parser.parse_args ()
+
+ if len(args) != 0:
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+ if options.rx_freq is None:
+ sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+ r = gr.enable_realtime_scheduling()
+ if r != gr.RT_OK:
+ print "Warning: Failed to enable realtime scheduling."
+
+ # Create an instance of a hierarchical block
+ top_block = my_graph(demods[options.modulation], rx_callback, options)
+
+ # Create an instance of a runtime, passing it the top block
+ runtime = gr.runtime(top_block)
+ runtime.start()
+
+ runtime.wait() # wait for it to finish
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/hier/digital/benchmark_tx.py b/gnuradio-examples/python/hier/digital/benchmark_tx.py
new file mode 100755
index 0000000000..627c92b3a0
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/benchmark_tx.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+#
+# Copyright 2005, 2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import usrp
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+import random, time, struct, sys
+
+# from current dir
+from transmit_path import transmit_path
+import fusb_options
+
+#import os
+#print os.getpid()
+#raw_input('Attach and press enter')
+
+class my_graph(gr.hier_block2):
+ def __init__(self, mod_class, options):
+ gr.hier_block2.__init__(self, "my_graph",
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+ self.txpath = transmit_path(mod_class, options)
+ self.define_component("txpath", self.txpath)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+def main():
+
+ def send_pkt(payload='', eof=False):
+ return top_block.txpath.send_pkt(payload, eof)
+
+ def rx_callback(ok, payload):
+ print "ok = %r, payload = '%s'" % (ok, payload)
+
+ mods = modulation_utils.type_1_mods()
+
+ parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
+ default='gmsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(mods.keys()),))
+
+ parser.add_option("-s", "--size", type="eng_float", default=1500,
+ help="set packet size [default=%default]")
+ parser.add_option("-M", "--megabytes", type="eng_float", default=1.0,
+ help="set megabytes to transmit [default=%default]")
+ parser.add_option("","--discontinuous", action="store_true", default=False,
+ help="enable discontinous transmission (bursts of 5 packets)")
+
+ transmit_path.add_options(parser, expert_grp)
+
+ for mod in mods.values():
+ mod.add_options(expert_grp)
+
+ fusb_options.add_options(expert_grp)
+ (options, args) = parser.parse_args ()
+
+ if len(args) != 0:
+ parser.print_help()
+ sys.exit(1)
+
+ if options.tx_freq is None:
+ sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+ r = gr.enable_realtime_scheduling()
+ if r != gr.RT_OK:
+ print "Warning: failed to enable realtime scheduling"
+
+ # Create an instance of a hierarchical block
+ top_block = my_graph(mods[options.modulation], options)
+
+ # Create an instance of a runtime, passing it the top block
+ runtime = gr.runtime(top_block)
+ runtime.start()
+
+ # generate and send packets
+ nbytes = int(1e6 * options.megabytes)
+ n = 0
+ pktno = 0
+ pkt_size = int(options.size)
+
+ while n < nbytes:
+ send_pkt(struct.pack('!H', pktno) + (pkt_size - 2) * chr(pktno & 0xff))
+ n += pkt_size
+ sys.stderr.write('.')
+ if options.discontinuous and pktno % 5 == 4:
+ time.sleep(1)
+ pktno += 1
+
+ send_pkt(eof=True)
+ runtime.wait()
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/hier/digital/fusb_options.py b/gnuradio-examples/python/hier/digital/fusb_options.py
new file mode 100644
index 0000000000..cdb15d72b3
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/fusb_options.py
@@ -0,0 +1,31 @@
+#
+# Copyright 2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+def add_options(parser):
+ """
+ Add Fast USB specifc options to command line parser.
+
+ @param parser: instance of OptionParser
+ """
+ parser.add_option("-B", "--fusb-block-size", type="int", default=0,
+ help="specify fast usb block size [default=%default]")
+ parser.add_option("-N", "--fusb-nblocks", type="int", default=0,
+ help="specify number of fast usb blocks [default=%default]")
diff --git a/gnuradio-examples/python/hier/digital/pick_bitrate.py b/gnuradio-examples/python/hier/digital/pick_bitrate.py
new file mode 100644
index 0000000000..42aefa94e3
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/pick_bitrate.py
@@ -0,0 +1,143 @@
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+_default_bitrate = 500e3
+
+_valid_samples_per_symbol = (2,3,4,5,6,7)
+
+def _gen_tx_info(converter_rate):
+ results = []
+ for samples_per_symbol in _valid_samples_per_symbol:
+ for interp in range(16, 512 + 1, 4):
+ bitrate = converter_rate / interp / samples_per_symbol
+ results.append((bitrate, samples_per_symbol, interp))
+ results.sort()
+ return results
+
+def _gen_rx_info(converter_rate):
+ results = []
+ for samples_per_symbol in _valid_samples_per_symbol:
+ for decim in range(8, 256 + 1, 2):
+ bitrate = converter_rate / decim / samples_per_symbol
+ results.append((bitrate, samples_per_symbol, decim))
+ results.sort()
+ return results
+
+def _filter_info(info, samples_per_symbol, xrate):
+ if samples_per_symbol is not None:
+ info = [x for x in info if x[1] == samples_per_symbol]
+ if xrate is not None:
+ info = [x for x in info if x[2] == xrate]
+ return info
+
+def _pick_best(target_bitrate, bits_per_symbol, info):
+ """
+ @returns tuple (bitrate, samples_per_symbol, interp_rate_or_decim_rate)
+ """
+ if len(info) == 0:
+ raise RuntimeError, "info is zero length!"
+
+ if target_bitrate is None: # return the fastest one
+ return info[-1]
+
+ # convert bit rate to symbol rate
+ target_symbolrate = target_bitrate / bits_per_symbol
+
+ # Find the closest matching symbol rate.
+ # In the event of a tie, the one with the lowest samples_per_symbol wins.
+ # (We already sorted them, so the first one is the one we take)
+
+ best = info[0]
+ best_delta = abs(target_symbolrate - best[0])
+ for x in info[1:]:
+ delta = abs(target_symbolrate - x[0])
+ if delta < best_delta:
+ best_delta = delta
+ best = x
+
+ # convert symbol rate back to bit rate
+ return ((best[0] * bits_per_symbol),) + best[1:]
+
+def _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
+ xrate, converter_rate, gen_info):
+ """
+ @returns tuple (bitrate, samples_per_symbol, interp_rate_or_decim_rate)
+ """
+ if not isinstance(bits_per_symbol, int) or bits_per_symbol < 1:
+ raise ValueError, "bits_per_symbol must be an int >= 1"
+
+ if samples_per_symbol is not None and xrate is not None: # completely determined
+ return (float(converter_rate) / xrate / samples_per_symbol,
+ samples_per_symbol, xrate)
+
+ if bitrate is None and samples_per_symbol is None and xrate is None:
+ bitrate = _default_bitrate
+
+ # now we have a target bitrate and possibly an xrate or
+ # samples_per_symbol constraint, but not both of them.
+
+ return _pick_best(bitrate, bits_per_symbol,
+ _filter_info(gen_info(converter_rate), samples_per_symbol, xrate))
+
+# ---------------------------------------------------------------------------------------
+
+def pick_tx_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
+ interp_rate, converter_rate=128e6):
+ """
+ Given the 4 input parameters, return at configuration that matches
+
+ @param bitrate: desired bitrate or None
+ @type bitrate: number or None
+ @param bits_per_symbol: E.g., BPSK -> 1, QPSK -> 2, 8-PSK -> 3
+ @type bits_per_symbol: integer >= 1
+ @param samples_per_symbol: samples/baud (aka samples/symbol)
+ @type samples_per_symbol: number or None
+ @param interp_rate: USRP interpolation factor
+ @type interp_rate: integer or None
+ @param converter_rate: converter sample rate in Hz
+ @type converter_rate: number
+
+ @returns tuple (bitrate, samples_per_symbol, interp_rate)
+ """
+ return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
+ interp_rate, converter_rate, _gen_tx_info)
+
+
+def pick_rx_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
+ decim_rate, converter_rate=64e6):
+ """
+ Given the 4 input parameters, return at configuration that matches
+
+ @param bitrate: desired bitrate or None
+ @type bitrate: number or None
+ @param bits_per_symbol: E.g., BPSK -> 1, QPSK -> 2, 8-PSK -> 3
+ @type bits_per_symbol: integer >= 1
+ @param samples_per_symbol: samples/baud (aka samples/symbol)
+ @type samples_per_symbol: number or None
+ @param decim_rate: USRP decimation factor
+ @type decim_rate: integer or None
+ @param converter_rate: converter sample rate in Hz
+ @type converter_rate: number
+
+ @returns tuple (bitrate, samples_per_symbol, decim_rate)
+ """
+ return _pick_bitrate(bitrate, bits_per_symbol, samples_per_symbol,
+ decim_rate, converter_rate, _gen_rx_info)
diff --git a/gnuradio-examples/python/hier/digital/receive_path.py b/gnuradio-examples/python/hier/digital/receive_path.py
new file mode 100644
index 0000000000..64a547dce0
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/receive_path.py
@@ -0,0 +1,264 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, blks2
+from gnuradio import usrp
+from gnuradio import eng_notation
+import copy
+import sys
+
+# from current dir
+from pick_bitrate import pick_rx_bitrate
+
+# /////////////////////////////////////////////////////////////////////////////
+# receive path
+# /////////////////////////////////////////////////////////////////////////////
+
+class receive_path(gr.hier_block2):
+ def __init__(self, demod_class, rx_callback, options):
+ gr.hier_block2.__init__(self, "receive_path",
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+
+ options = copy.copy(options) # make a copy so we can destructively modify
+
+ self._verbose = options.verbose
+ self._rx_freq = options.rx_freq # receiver's center frequency
+ self._rx_gain = options.rx_gain # receiver's gain
+ self._rx_subdev_spec = options.rx_subdev_spec # daughterboard to use
+ self._bitrate = options.bitrate # desired bit rate
+ self._decim = options.decim # Decimating rate for the USRP (prelim)
+ self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
+ self._fusb_block_size = options.fusb_block_size # usb info for USRP
+ self._fusb_nblocks = options.fusb_nblocks # usb info for USRP
+
+ self._rx_callback = rx_callback # this callback is fired when there's a packet available
+ self._demod_class = demod_class # the demodulator_class we're using
+
+ if self._rx_freq is None:
+ sys.stderr.write("-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
+ raise SystemExit
+
+ # Set up USRP source; also adjusts decim, samples_per_symbol, and bitrate
+ self._setup_usrp_source()
+
+ g = self.subdev.gain_range()
+ if options.show_rx_gain_range:
+ print "Rx Gain Range: minimum = %g, maximum = %g, step size = %g" \
+ % (g[0], g[1], g[2])
+
+ self.set_gain(options.rx_gain)
+
+ self.set_auto_tr(True) # enable Auto Transmit/Receive switching
+
+ # Set RF frequency
+ ok = self.set_freq(self._rx_freq)
+ if not ok:
+ print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(self._rx_freq))
+ raise ValueError, eng_notation.num_to_str(self._rx_freq)
+
+ # copy the final answers back into options for use by demodulator
+ options.samples_per_symbol = self._samples_per_symbol
+ options.bitrate = self._bitrate
+ options.decim = self._decim
+
+ # Get demod_kwargs
+ demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
+
+ # Design filter to get actual channel we want
+ sw_decim = 1
+ chan_coeffs = gr.firdes.low_pass (1.0, # gain
+ sw_decim * self._samples_per_symbol, # sampling rate
+ 1.0, # midpoint of trans. band
+ 0.5, # width of trans. band
+ gr.firdes.WIN_HANN) # filter type
+
+ # Decimating channel filter
+ # complex in and out, float taps
+ self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)
+ #self.chan_filt = gr.fir_filter_ccf(sw_decim, chan_coeffs)
+ # receiver
+ self.packet_receiver = \
+ blks2.demod_pkts(self._demod_class(**demod_kwargs),
+ access_code=None,
+ callback=self._rx_callback,
+ threshold=-1)
+
+ # Carrier Sensing Blocks
+ alpha = 0.001
+ thresh = 30 # in dB, will have to adjust
+ self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
+
+ # Display some information about the setup
+ if self._verbose:
+ self._print_verbage()
+
+ # Define the components
+ self.define_component("usrp", self.u)
+ self.define_component("channel_filter", gr.fft_filter_ccc(sw_decim, chan_coeffs))
+ self.define_component("channel_probe", self.probe)
+ self.define_component("packet_receiver", self.packet_receiver)
+
+ # connect the channel input filter to the carrier power detector
+ self.connect("usrp", 0, "channel_filter", 0)
+ self.connect("channel_filter", 0, "channel_probe", 0)
+
+ # connect channel filter to the packet receiver
+ self.connect("channel_filter", 0, "packet_receiver", 0)
+
+
+ def _setup_usrp_source(self):
+ self.u = usrp.source_c (fusb_block_size=self._fusb_block_size,
+ fusb_nblocks=self._fusb_nblocks)
+ adc_rate = self.u.adc_rate()
+
+ # derive values of bitrate, samples_per_symbol, and decim from desired info
+ (self._bitrate, self._samples_per_symbol, self._decim) = \
+ pick_rx_bitrate(self._bitrate, self._demod_class.bits_per_symbol(), \
+ self._samples_per_symbol, self._decim, adc_rate)
+
+ self.u.set_decim_rate(self._decim)
+
+ # determine the daughterboard subdevice we're using
+ if self._rx_subdev_spec is None:
+ self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
+ self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec)
+
+ self.u.set_mux(usrp.determine_rx_mux_value(self.u, self._rx_subdev_spec))
+
+ def set_freq(self, target_freq):
+ """
+ Set the center frequency we're interested in.
+
+ @param target_freq: frequency in Hz
+ @rypte: bool
+
+ Tuning is a two step process. First we ask the front-end to
+ tune as close to the desired frequency as it can. Then we use
+ the result of that operation and our target_frequency to
+ determine the value for the digital up converter.
+ """
+ r = self.u.tune(0, self.subdev, target_freq)
+ if r:
+ return True
+
+ return False
+
+ def set_gain(self, gain):
+ """
+ Sets the analog gain in the USRP
+ """
+ if gain is None:
+ r = self.subdev.gain_range()
+ gain = (r[0] + r[1])/2 # set gain to midpoint
+ self.gain = gain
+ return self.subdev.set_gain(gain)
+
+ def set_auto_tr(self, enable):
+ return self.subdev.set_auto_tr(enable)
+
+ def bitrate(self):
+ return self._bitrate
+
+ def samples_per_symbol(self):
+ return self._samples_per_symbol
+
+ def decim(self):
+ return self._decim
+
+ def carrier_sensed(self):
+ """
+ Return True if we think carrier is present.
+ """
+ #return self.probe.level() > X
+ return self.probe.unmuted()
+
+ def carrier_threshold(self):
+ """
+ Return current setting in dB.
+ """
+ return self.probe.threshold()
+
+ def set_carrier_threshold(self, threshold_in_db):
+ """
+ Set carrier threshold.
+
+ @param threshold_in_db: set detection threshold
+ @type threshold_in_db: float (dB)
+ """
+ self.probe.set_threshold(threshold_in_db)
+
+
+ def add_options(normal, expert):
+ """
+ Adds receiver-specific options to the Options Parser
+ """
+ add_freq_option(normal)
+ if not normal.has_option("--bitrate"):
+ normal.add_option("-r", "--bitrate", type="eng_float", default=None,
+ help="specify bitrate. samples-per-symbol and interp/decim will be derived.")
+ normal.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
+ help="select USRP Rx side A or B")
+ normal.add_option("", "--rx-gain", type="eng_float", default=None, metavar="GAIN",
+ help="set receiver gain in dB [default=midpoint]. See also --show-rx-gain-range")
+ normal.add_option("", "--show-rx-gain-range", action="store_true", default=False,
+ help="print min and max Rx gain available on selected daughterboard")
+ normal.add_option("-v", "--verbose", action="store_true", default=False)
+ expert.add_option("-S", "--samples-per-symbol", type="int", default=None,
+ help="set samples/symbol [default=%default]")
+ expert.add_option("", "--rx-freq", type="eng_float", default=None,
+ help="set Rx frequency to FREQ [default=%default]", metavar="FREQ")
+ expert.add_option("-d", "--decim", type="intx", default=None,
+ help="set fpga decimation rate to DECIM [default=%default]")
+ expert.add_option("", "--log", action="store_true", default=False,
+ help="Log all parts of flow graph to files (CAUTION: lots of data)")
+
+ # Make a static method to call before instantiation
+ add_options = staticmethod(add_options)
+
+
+ def _print_verbage(self):
+ """
+ Prints information about the receive path
+ """
+ print "\nReceive Path:"
+ print "Using RX d'board %s" % (self.subdev.side_and_name(),)
+ print "Rx gain: %g" % (self.gain,)
+ print "modulation: %s" % (self._demod_class.__name__)
+ print "bitrate: %sb/s" % (eng_notation.num_to_str(self._bitrate))
+ print "samples/symbol: %3d" % (self._samples_per_symbol)
+ print "decim: %3d" % (self._decim)
+ print "Rx Frequency: %s" % (eng_notation.num_to_str(self._rx_freq))
+
+def add_freq_option(parser):
+ """
+ Hackery that has the -f / --freq option set both tx_freq and rx_freq
+ """
+ def freq_callback(option, opt_str, value, parser):
+ parser.values.rx_freq = value
+ parser.values.tx_freq = value
+
+ if not parser.has_option('--freq'):
+ parser.add_option('-f', '--freq', type="eng_float",
+ action="callback", callback=freq_callback,
+ help="set Tx and/or Rx frequency to FREQ [default=%default]",
+ metavar="FREQ")
diff --git a/gnuradio-examples/python/hier/digital/receive_path_lb.py b/gnuradio-examples/python/hier/digital/receive_path_lb.py
new file mode 100644
index 0000000000..fada441ffc
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/receive_path_lb.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, blks2
+from gnuradio import eng_notation
+import copy
+import sys
+
+# /////////////////////////////////////////////////////////////////////////////
+# receive path
+# /////////////////////////////////////////////////////////////////////////////
+
+class receive_path(gr.hier_block2):
+ def __init__(self, demod_class, rx_callback, options):
+ gr.hier_block2.__init__(self, "receive_path",
+ gr.io_signature(1,1,gr.sizeof_gr_complex), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+
+ options = copy.copy(options) # make a copy so we can destructively modify
+
+ self._verbose = options.verbose
+ self._bitrate = options.bitrate # desired bit rate
+ self._samples_per_symbol = options.samples_per_symbol # desired samples/symbol
+
+ self._rx_callback = rx_callback # this callback is fired when there's a packet available
+ self._demod_class = demod_class # the demodulator_class we're using
+
+ # Get demod_kwargs
+ demod_kwargs = self._demod_class.extract_kwargs_from_options(options)
+
+ # Design filter to get actual channel we want
+ sw_decim = 1
+ chan_coeffs = gr.firdes.low_pass (1.0, # gain
+ sw_decim * self._samples_per_symbol, # sampling rate
+ 1.0, # midpoint of trans. band
+ 0.5, # width of trans. band
+ gr.firdes.WIN_HANN) # filter type
+
+ # receiver
+ self.packet_receiver = \
+ blks2.demod_pkts(self._demod_class(**demod_kwargs),
+ access_code=None,
+ callback=self._rx_callback,
+ threshold=-1)
+
+ # Carrier Sensing Blocks
+ alpha = 0.001
+ thresh = 30 # in dB, will have to adjust
+ self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)
+
+ # Display some information about the setup
+ if self._verbose:
+ self._print_verbage()
+
+ # Define the components
+ self.define_component("channel_filter", gr.fft_filter_ccc(sw_decim, chan_coeffs))
+ self.define_component("channel_probe", self.probe)
+ self.define_component("packet_receiver", self.packet_receiver)
+
+ # connect the channel input filter to the carrier power detector
+ self.connect("self", 0, "channel_filter", 0)
+ self.connect("channel_filter", 0, "channel_probe", 0)
+
+ # connect channel filter to the packet receiver
+ self.connect("channel_filter", 0, "packet_receiver", 0)
+
+ def bitrate(self):
+ return self._bitrate
+
+ def samples_per_symbol(self):
+ return self._samples_per_symbol
+
+ def carrier_sensed(self):
+ """
+ Return True if we think carrier is present.
+ """
+ #return self.probe.level() > X
+ return self.probe.unmuted()
+
+ def carrier_threshold(self):
+ """
+ Return current setting in dB.
+ """
+ return self.probe.threshold()
+
+ def set_carrier_threshold(self, threshold_in_db):
+ """
+ Set carrier threshold.
+
+ @param threshold_in_db: set detection threshold
+ @type threshold_in_db: float (dB)
+ """
+ self.probe.set_threshold(threshold_in_db)
+
+
+ def add_options(normal, expert):
+ """
+ Adds receiver-specific options to the Options Parser
+ """
+ if not normal.has_option("--bitrate"):
+ normal.add_option("-r", "--bitrate", type="eng_float", default=100e3,
+ help="specify bitrate [default=%default].")
+ normal.add_option("", "--show-rx-gain-range", action="store_true", default=False,
+ help="print min and max Rx gain available on selected daughterboard")
+ normal.add_option("-v", "--verbose", action="store_true", default=False)
+ expert.add_option("-S", "--samples-per-symbol", type="int", default=2,
+ help="set samples/symbol [default=%default]")
+ expert.add_option("", "--log", action="store_true", default=False,
+ help="Log all parts of flow graph to files (CAUTION: lots of data)")
+
+ # Make a static method to call before instantiation
+ add_options = staticmethod(add_options)
+
+
+ def _print_verbage(self):
+ """
+ Prints information about the receive path
+ """
+ print "modulation: %s" % (self._demod_class.__name__)
+ print "bitrate: %sb/s" % (eng_notation.num_to_str(self._bitrate))
+ print "samples/symbol: %3d" % (self._samples_per_symbol)
diff --git a/gnuradio-examples/python/hier/digital/rx_voice.py b/gnuradio-examples/python/hier/digital/rx_voice.py
new file mode 100755
index 0000000000..1304862458
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/rx_voice.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import usrp
+from gnuradio import audio
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+from gnuradio.vocoder import gsm_full_rate
+
+import random
+import struct
+
+# from current dir
+from receive_path import receive_path
+import fusb_options
+
+#import os
+#print os.getpid()
+#raw_input('Attach and press enter')
+
+
+class audio_tx(gr.hier_block):
+ def __init__(self, fg, audio_output_dev):
+ self.packet_src = gr.message_source(33)
+ voice_decoder = gsm_full_rate.decode_ps()
+ s2f = gr.short_to_float ()
+ sink_scale = gr.multiply_const_ff(1.0/32767.)
+ audio_sink = audio.sink(8000, audio_output_dev)
+ fg.connect(self.packet_src, voice_decoder, s2f, sink_scale, audio_sink)
+ gr.hier_block.__init__(self, fg, self.packet_src, audio_sink)
+
+ def msgq(self):
+ return self.packet_src.msgq()
+
+
+class my_graph(gr.flow_graph):
+
+ def __init__(self, demod_class, rx_callback, options):
+ gr.flow_graph.__init__(self)
+ self.rxpath = receive_path(self, demod_class, rx_callback, options)
+ self.audio_tx = audio_tx(self, options.audio_output)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+global n_rcvd, n_right
+
+def main():
+ global n_rcvd, n_right
+
+ n_rcvd = 0
+ n_right = 0
+
+ def rx_callback(ok, payload):
+ global n_rcvd, n_right
+ n_rcvd += 1
+ if ok:
+ n_right += 1
+
+ fg.audio_tx.msgq().insert_tail(gr.message_from_string(payload))
+
+ print "ok = %r n_rcvd = %4d n_right = %4d" % (
+ ok, n_rcvd, n_right)
+
+ demods = modulation_utils.type_1_demods()
+
+ # Create Options Parser:
+ parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(),
+ default='gmsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(demods.keys()),))
+ parser.add_option("-O", "--audio-output", type="string", default="",
+ help="pcm output device name. E.g., hw:0,0 or /dev/dsp")
+
+ receive_path.add_options(parser, expert_grp)
+
+ for mod in demods.values():
+ mod.add_options(expert_grp)
+
+ fusb_options.add_options(expert_grp)
+
+ parser.set_defaults(bitrate=50e3) # override default bitrate default
+ (options, args) = parser.parse_args ()
+
+ if len(args) != 0:
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+ if options.rx_freq is None:
+ sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+
+ # build the graph
+ fg = my_graph(demods[options.modulation], rx_callback, options)
+
+ r = gr.enable_realtime_scheduling()
+ if r != gr.RT_OK:
+ print "Warning: Failed to enable realtime scheduling."
+
+ fg.start() # start flow graph
+ fg.wait() # wait for it to finish
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/hier/digital/transmit_path.py b/gnuradio-examples/python/hier/digital/transmit_path.py
new file mode 100644
index 0000000000..c517210aef
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/transmit_path.py
@@ -0,0 +1,239 @@
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, blks2
+from gnuradio import usrp
+from gnuradio import eng_notation
+
+import copy
+import sys
+
+# from current dir
+from pick_bitrate import pick_tx_bitrate
+
+# /////////////////////////////////////////////////////////////////////////////
+# transmit path
+# /////////////////////////////////////////////////////////////////////////////
+
+class transmit_path(gr.hier_block2):
+ def __init__(self, modulator_class, options):
+ '''
+ See below for what options should hold
+ '''
+
+ gr.hier_block2.__init__(self, "transmit_path",
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+
+ options = copy.copy(options) # make a copy so we can destructively modify
+
+ self._verbose = options.verbose
+ self._tx_freq = options.tx_freq # tranmitter's center frequency
+ self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP
+ self._tx_subdev_spec = options.tx_subdev_spec # daughterboard to use
+ self._bitrate = options.bitrate # desired bit rate
+ self._interp = options.interp # interpolating rate for the USRP (prelim)
+ self._samples_per_symbol = options.samples_per_symbol # desired samples/baud
+ self._fusb_block_size = options.fusb_block_size # usb info for USRP
+ self._fusb_nblocks = options.fusb_nblocks # usb info for USRP
+
+ self._modulator_class = modulator_class # the modulator_class we are using
+
+ if self._tx_freq is None:
+ sys.stderr.write("-f FREQ or --freq FREQ or --tx-freq FREQ must be specified\n")
+ raise SystemExit
+
+ # Set up USRP sink; also adjusts interp, samples_per_symbol, and bitrate
+ self._setup_usrp_sink()
+
+ # copy the final answers back into options for use by modulator
+ options.samples_per_symbol = self._samples_per_symbol
+ options.bitrate = self._bitrate
+ options.interp = self._interp
+
+ # Get mod_kwargs
+ mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)
+
+ # 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
+
+ # transmitter
+ self.packet_transmitter = \
+ blks2.mod_pkts(self._modulator_class(**mod_kwargs),
+ access_code=None,
+ msgq_limit=4,
+ pad_for_usrp=True)
+
+ # Set the USRP for maximum transmit gain
+ # (Note that on the RFX cards this is a nop.)
+ self.set_gain(self.subdev.gain_range()[0])
+
+ self.amp = gr.multiply_const_cc(1)
+ self.set_tx_amplitude(self._tx_amplitude)
+
+ # enable Auto Transmit/Receive switching
+ self.set_auto_tr(True)
+
+ # Display some information about the setup
+ if self._verbose:
+ self._print_verbage()
+
+ # Define the components
+ self.define_component("packet_transmitter", self.packet_transmitter)
+ self.define_component("amp", self.amp)
+ self.define_component("usrp", self.u)
+
+ # Connect components in the flowgraph; set amp component to the output of this block
+ self.connect("packet_transmitter", 0, "amp", 0)
+ self.connect("amp", 0, "usrp", 0)
+
+ 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)
+ 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)
+ 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 set_freq(self, target_freq):
+ """
+ Set the center frequency we're interested in.
+
+ @param target_freq: frequency in Hz
+ @rypte: bool
+
+ Tuning is a two step process. First we ask the front-end to
+ tune as close to the desired frequency as it can. Then we use
+ the result of that operation and our target_frequency to
+ determine the value for the digital up converter.
+ """
+ r = self.u.tune(self.subdev._which, self.subdev, target_freq)
+ if r:
+ return True
+
+ return False
+
+ def set_gain(self, gain):
+ """
+ Sets the analog gain in the USRP
+ """
+ self.gain = gain
+ self.subdev.set_gain(gain)
+
+ def set_tx_amplitude(self, ampl):
+ """
+ Sets the transmit amplitude sent to the USRP
+ @param: ampl 0 <= ampl < 32768. Try 8000
+ """
+ self._tx_amplitude = max(0.0, min(ampl, 32767.0))
+ self.amp.set_k(self._tx_amplitude)
+
+ def set_auto_tr(self, enable):
+ """
+ Turns on auto transmit/receive of USRP daughterboard (if exits; else ignored)
+ """
+ return self.subdev.set_auto_tr(enable)
+
+ def send_pkt(self, payload='', eof=False):
+ """
+ Calls the transmitter method to send a packet
+ """
+ return self.packet_transmitter.send_pkt(payload, eof)
+
+ def bitrate(self):
+ return self._bitrate
+
+ def samples_per_symbol(self):
+ return self._samples_per_symbol
+
+ def interp(self):
+ return self._interp
+
+ def add_options(normal, expert):
+ """
+ Adds transmitter-specific options to the Options Parser
+ """
+ add_freq_option(normal)
+ if not normal.has_option('--bitrate'):
+ normal.add_option("-r", "--bitrate", type="eng_float", default=None,
+ help="specify bitrate. samples-per-symbol and interp/decim will be derived.")
+ normal.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
+ help="select USRP Tx side A or B")
+ normal.add_option("", "--tx-amplitude", type="eng_float", default=12000, metavar="AMPL",
+ help="set transmitter digital amplitude: 0 <= AMPL < 32768 [default=%default]")
+ normal.add_option("-v", "--verbose", action="store_true", default=False)
+
+ expert.add_option("-S", "--samples-per-symbol", type="int", default=None,
+ help="set samples/symbol [default=%default]")
+ expert.add_option("", "--tx-freq", type="eng_float", default=None,
+ help="set transmit frequency to FREQ [default=%default]", metavar="FREQ")
+ expert.add_option("-i", "--interp", type="intx", default=None,
+ help="set fpga interpolation rate to INTERP [default=%default]")
+ expert.add_option("", "--log", action="store_true", default=False,
+ help="Log all parts of flow graph to file (CAUTION: lots of data)")
+
+ # Make a static method to call before instantiation
+ add_options = staticmethod(add_options)
+
+ def _print_verbage(self):
+ """
+ Prints information about the transmit path
+ """
+ print "Using TX d'board %s" % (self.subdev.side_and_name(),)
+ print "Tx amplitude %s" % (self._tx_amplitude)
+ print "modulation: %s" % (self._modulator_class.__name__)
+ print "bitrate: %sb/s" % (eng_notation.num_to_str(self._bitrate))
+ print "samples/symbol: %3d" % (self._samples_per_symbol)
+ print "interp: %3d" % (self._interp)
+ print "Tx Frequency: %s" % (eng_notation.num_to_str(self._tx_freq))
+
+
+def add_freq_option(parser):
+ """
+ Hackery that has the -f / --freq option set both tx_freq and rx_freq
+ """
+ def freq_callback(option, opt_str, value, parser):
+ parser.values.rx_freq = value
+ parser.values.tx_freq = value
+
+ if not parser.has_option('--freq'):
+ parser.add_option('-f', '--freq', type="eng_float",
+ action="callback", callback=freq_callback,
+ help="set Tx and/or Rx frequency to FREQ [default=%default]",
+ metavar="FREQ")
diff --git a/gnuradio-examples/python/hier/digital/transmit_path_lb.py b/gnuradio-examples/python/hier/digital/transmit_path_lb.py
new file mode 100644
index 0000000000..7bf4b60577
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/transmit_path_lb.py
@@ -0,0 +1,123 @@
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, blks2
+from gnuradio import eng_notation
+
+import copy
+import sys
+
+# /////////////////////////////////////////////////////////////////////////////
+# transmit path
+# /////////////////////////////////////////////////////////////////////////////
+
+class transmit_path(gr.hier_block2):
+ def __init__(self, modulator_class, options):
+ '''
+ See below for what options should hold
+ '''
+
+ gr.hier_block2.__init__(self, "transmit_path",
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(1,1,gr.sizeof_gr_complex)) # Output signature
+
+ options = copy.copy(options) # make a copy so we can destructively modify
+
+ self._verbose = options.verbose
+ self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP
+ self._bitrate = options.bitrate # desired bit rate
+ self._samples_per_symbol = options.samples_per_symbol # desired samples/baud
+
+ self._modulator_class = modulator_class # the modulator_class we are using
+
+ # Get mod_kwargs
+ mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)
+
+ # transmitter
+ self.packet_transmitter = \
+ blks2.mod_pkts(self._modulator_class(**mod_kwargs),
+ access_code=None,
+ msgq_limit=4,
+ pad_for_usrp=True)
+
+ self.amp = gr.multiply_const_cc(1)
+ self.set_tx_amplitude(self._tx_amplitude)
+
+ # Display some information about the setup
+ if self._verbose:
+ self._print_verbage()
+
+ # Define the components
+ self.define_component("packet_transmitter", self.packet_transmitter)
+ self.define_component("amp", self.amp)
+
+ # Connect components in the flowgraph; set amp component to the output of this block
+ self.connect("packet_transmitter", 0, "amp", 0)
+ self.connect("amp", 0, "self", 0)
+
+ def set_tx_amplitude(self, ampl):
+ """
+ Sets the transmit amplitude sent to the USRP
+ @param: ampl 0 <= ampl < 32768. Try 8000
+ """
+ self._tx_amplitude = max(0.0, min(ampl, 32767.0))
+ self.amp.set_k(self._tx_amplitude)
+
+ def send_pkt(self, payload='', eof=False):
+ """
+ Calls the transmitter method to send a packet
+ """
+ return self.packet_transmitter.send_pkt(payload, eof)
+
+ def bitrate(self):
+ return self._bitrate
+
+ def samples_per_symbol(self):
+ return self._samples_per_symbol
+
+ def add_options(normal, expert):
+ """
+ Adds transmitter-specific options to the Options Parser
+ """
+ if not normal.has_option('--bitrate'):
+ normal.add_option("-r", "--bitrate", type="eng_float", default=100e3,
+ help="specify bitrate [default=%default].")
+ normal.add_option("", "--tx-amplitude", type="eng_float", default=12000, metavar="AMPL",
+ help="set transmitter digital amplitude: 0 <= AMPL < 32768 [default=%default]")
+ normal.add_option("-v", "--verbose", action="store_true", default=False)
+
+ expert.add_option("-S", "--samples-per-symbol", type="int", default=2,
+ help="set samples/symbol [default=%default]")
+ expert.add_option("", "--log", action="store_true", default=False,
+ help="Log all parts of flow graph to file (CAUTION: lots of data)")
+
+ # Make a static method to call before instantiation
+ add_options = staticmethod(add_options)
+
+ def _print_verbage(self):
+ """
+ Prints information about the transmit path
+ """
+ print "Tx amplitude %s" % (self._tx_amplitude)
+ print "modulation: %s" % (self._modulator_class.__name__)
+ print "bitrate: %sb/s" % (eng_notation.num_to_str(self._bitrate))
+ print "samples/symbol: %3d" % (self._samples_per_symbol)
+
diff --git a/gnuradio-examples/python/hier/digital/tunnel.py b/gnuradio-examples/python/hier/digital/tunnel.py
new file mode 100755
index 0000000000..56229f5360
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/tunnel.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#
+# This code sets up up a virtual ethernet interface (typically gr0),
+# and relays packets between the interface and the GNU Radio PHY+MAC
+#
+# What this means in plain language, is that if you've got a couple
+# of USRPs on different machines, and if you run this code on those
+# machines, you can talk between them using normal TCP/IP networking.
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import usrp
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+import random
+import time
+import struct
+import sys
+import os
+
+# from current dir
+from transmit_path import transmit_path
+from receive_path import receive_path
+import fusb_options
+
+#print os.getpid()
+#raw_input('Attach and press enter')
+
+
+# /////////////////////////////////////////////////////////////////////////////
+#
+# Use the Universal TUN/TAP device driver to move packets to/from kernel
+#
+# See /usr/src/linux/Documentation/networking/tuntap.txt
+#
+# /////////////////////////////////////////////////////////////////////////////
+
+# Linux specific...
+# TUNSETIFF ifr flags from <linux/tun_if.h>
+
+IFF_TUN = 0x0001 # tunnel IP packets
+IFF_TAP = 0x0002 # tunnel ethernet frames
+IFF_NO_PI = 0x1000 # don't pass extra packet info
+IFF_ONE_QUEUE = 0x2000 # beats me ;)
+
+def open_tun_interface(tun_device_filename):
+ from fcntl import ioctl
+
+ mode = IFF_TAP | IFF_NO_PI
+ TUNSETIFF = 0x400454ca
+
+ tun = os.open(tun_device_filename, os.O_RDWR)
+ ifs = ioctl(tun, TUNSETIFF, struct.pack("16sH", "gr%d", mode))
+ ifname = ifs[:16].strip("\x00")
+ return (tun, ifname)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# the flow graph
+# /////////////////////////////////////////////////////////////////////////////
+
+class my_graph(gr.flow_graph):
+
+ def __init__(self, mod_class, demod_class,
+ rx_callback, options):
+
+ gr.flow_graph.__init__(self)
+ self.txpath = transmit_path(self, mod_class, options)
+ self.rxpath = receive_path(self, demod_class, rx_callback, options)
+
+ def send_pkt(self, payload='', eof=False):
+ return self.txpath.send_pkt(payload, eof)
+
+ def carrier_sensed(self):
+ """
+ Return True if the receive path thinks there's carrier
+ """
+ return self.rxpath.carrier_sensed()
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# Carrier Sense MAC
+# /////////////////////////////////////////////////////////////////////////////
+
+class cs_mac(object):
+ """
+ Prototype carrier sense MAC
+
+ Reads packets from the TUN/TAP interface, and sends them to the PHY.
+ Receives packets from the PHY via phy_rx_callback, and sends them
+ into the TUN/TAP interface.
+
+ Of course, we're not restricted to getting packets via TUN/TAP, this
+ is just an example.
+ """
+ def __init__(self, tun_fd, verbose=False):
+ self.tun_fd = tun_fd # file descriptor for TUN/TAP interface
+ self.verbose = verbose
+ self.fg = None # flow graph (access to PHY)
+
+ def set_flow_graph(self, fg):
+ self.fg = fg
+
+ def phy_rx_callback(self, ok, payload):
+ """
+ Invoked by thread associated with PHY to pass received packet up.
+
+ @param ok: bool indicating whether payload CRC was OK
+ @param payload: contents of the packet (string)
+ """
+ if self.verbose:
+ print "Rx: ok = %r len(payload) = %4d" % (ok, len(payload))
+ if ok:
+ os.write(self.tun_fd, payload)
+
+ def main_loop(self):
+ """
+ Main loop for MAC.
+ Only returns if we get an error reading from TUN.
+
+ FIXME: may want to check for EINTR and EAGAIN and reissue read
+ """
+ min_delay = 0.001 # seconds
+
+ while 1:
+ payload = os.read(self.tun_fd, 10*1024)
+ if not payload:
+ self.fg.send_pkt(eof=True)
+ break
+
+ if self.verbose:
+ print "Tx: len(payload) = %4d" % (len(payload),)
+
+ delay = min_delay
+ while self.fg.carrier_sensed():
+ sys.stderr.write('B')
+ time.sleep(delay)
+ if delay < 0.050:
+ delay = delay * 2 # exponential back-off
+
+ self.fg.send_pkt(payload)
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+def main():
+
+ mods = modulation_utils.type_1_mods()
+ demods = modulation_utils.type_1_demods()
+
+ parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
+ default='gmsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(mods.keys()),))
+
+ parser.add_option("-v","--verbose", action="store_true", default=False)
+ expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
+ help="set carrier detect threshold (dB) [default=%default]")
+ expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
+ help="path to tun device file [default=%default]")
+
+ transmit_path.add_options(parser, expert_grp)
+ receive_path.add_options(parser, expert_grp)
+
+ for mod in mods.values():
+ mod.add_options(expert_grp)
+
+ for demod in demods.values():
+ demod.add_options(expert_grp)
+
+ fusb_options.add_options(expert_grp)
+
+ (options, args) = parser.parse_args ()
+ if len(args) != 0:
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+ if options.rx_freq is None or options.tx_freq is None:
+ sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+ # open the TUN/TAP interface
+ (tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
+
+ # Attempt to enable realtime scheduling
+ r = gr.enable_realtime_scheduling()
+ if r == gr.RT_OK:
+ realtime = True
+ else:
+ realtime = False
+ print "Note: failed to enable realtime scheduling"
+
+
+ # If the user hasn't set the fusb_* parameters on the command line,
+ # pick some values that will reduce latency.
+
+ if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
+ if realtime: # be more aggressive
+ options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
+ options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
+ else:
+ options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
+ options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
+
+ #print "fusb_block_size =", options.fusb_block_size
+ #print "fusb_nblocks =", options.fusb_nblocks
+
+ # instantiate the MAC
+ mac = cs_mac(tun_fd, verbose=True)
+
+
+ # build the graph (PHY)
+ fg = my_graph(mods[options.modulation],
+ demods[options.modulation],
+ mac.phy_rx_callback,
+ options)
+
+ mac.set_flow_graph(fg) # give the MAC a handle for the PHY
+
+ if fg.txpath.bitrate() != fg.rxpath.bitrate():
+ print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
+ eng_notation.num_to_str(fg.txpath.bitrate()),
+ eng_notation.num_to_str(fg.rxpath.bitrate()))
+
+ print "modulation: %s" % (options.modulation,)
+ print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
+ print "bitrate: %sb/sec" % (eng_notation.num_to_str(fg.txpath.bitrate()),)
+ print "samples/symbol: %3d" % (fg.txpath.samples_per_symbol(),)
+ #print "interp: %3d" % (fg.txpath.interp(),)
+ #print "decim: %3d" % (fg.rxpath.decim(),)
+
+ fg.rxpath.set_carrier_threshold(options.carrier_threshold)
+ print "Carrier sense threshold:", options.carrier_threshold, "dB"
+
+ print
+ print "Allocated virtual ethernet interface: %s" % (tun_ifname,)
+ print "You must now use ifconfig to set its IP address. E.g.,"
+ print
+ print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname,)
+ print
+ print "Be sure to use a different address in the same subnet for each machine."
+ print
+
+
+ fg.start() # Start executing the flow graph (runs in separate threads)
+
+ mac.main_loop() # don't expect this to return...
+
+ fg.stop() # but if it does, tell flow graph to stop.
+ fg.wait() # wait for it to finish
+
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/hier/digital/tx_voice.py b/gnuradio-examples/python/hier/digital/tx_voice.py
new file mode 100755
index 0000000000..eba0c3c719
--- /dev/null
+++ b/gnuradio-examples/python/hier/digital/tx_voice.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+#
+# Copyright 2005,2006 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gru, modulation_utils
+from gnuradio import usrp
+from gnuradio import audio
+from gnuradio import eng_notation
+from gnuradio.eng_option import eng_option
+from optparse import OptionParser
+
+from gnuradio.vocoder import gsm_full_rate
+
+import random
+import time
+import struct
+import sys
+
+# from current dir
+from transmit_path import transmit_path
+import fusb_options
+
+#import os
+#print os.getpid()
+#raw_input('Attach and press enter')
+
+
+class audio_rx(gr.hier_block):
+ def __init__(self, fg, audio_input_dev):
+ sample_rate = 8000
+ src = audio.source(sample_rate, audio_input_dev)
+ src_scale = gr.multiply_const_ff(32767)
+ f2s = gr.float_to_short()
+ voice_coder = gsm_full_rate.encode_sp()
+ self.packets_from_encoder = gr.msg_queue()
+ packet_sink = gr.message_sink(33, self.packets_from_encoder, False)
+ fg.connect(src, src_scale, f2s, voice_coder, packet_sink)
+ gr.hier_block.__init__(self, fg, src, packet_sink)
+
+ def get_encoded_voice_packet(self):
+ return self.packets_from_encoder.delete_head()
+
+
+class my_graph(gr.flow_graph):
+
+ def __init__(self, modulator_class, options):
+ gr.flow_graph.__init__(self)
+ self.txpath = transmit_path(self, modulator_class, options)
+ self.audio_rx = audio_rx(self, options.audio_input)
+
+
+
+# /////////////////////////////////////////////////////////////////////////////
+# main
+# /////////////////////////////////////////////////////////////////////////////
+
+def main():
+
+ def send_pkt(payload='', eof=False):
+ return fg.txpath.send_pkt(payload, eof)
+
+ def rx_callback(ok, payload):
+ print "ok = %r, payload = '%s'" % (ok, payload)
+
+ mods = modulation_utils.type_1_mods()
+
+ parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
+ expert_grp = parser.add_option_group("Expert")
+
+ parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
+ default='gmsk',
+ help="Select modulation from: %s [default=%%default]"
+ % (', '.join(mods.keys()),))
+ parser.add_option("-M", "--megabytes", type="eng_float", default=0,
+ help="set megabytes to transmit [default=inf]")
+ parser.add_option("-I", "--audio-input", type="string", default="",
+ help="pcm input device name. E.g., hw:0,0 or /dev/dsp")
+
+ transmit_path.add_options(parser, expert_grp)
+
+ for mod in mods.values():
+ mod.add_options(expert_grp)
+
+ fusb_options.add_options(expert_grp)
+
+ parser.set_defaults(bitrate=50e3) # override default bitrate default
+ (options, args) = parser.parse_args ()
+
+ if len(args) != 0:
+ parser.print_help()
+ sys.exit(1)
+
+ if options.tx_freq is None:
+ sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
+ parser.print_help(sys.stderr)
+ sys.exit(1)
+
+
+ # build the graph
+ fg = my_graph(mods[options.modulation], options)
+
+ r = gr.enable_realtime_scheduling()
+ if r != gr.RT_OK:
+ print "Warning: failed to enable realtime scheduling"
+
+
+ fg.start() # start flow graph
+
+ # generate and send packets
+ nbytes = int(1e6 * options.megabytes)
+ n = 0
+ pktno = 0
+
+ while nbytes == 0 or n < nbytes:
+ packet = fg.audio_rx.get_encoded_voice_packet()
+ s = packet.to_string()
+ send_pkt(s)
+ n += len(s)
+ sys.stderr.write('.')
+ pktno += 1
+
+ send_pkt(eof=True)
+ fg.wait() # wait for it to finish
+ fg.txpath.set_auto_tr(False)
+
+
+if __name__ == '__main__':
+ try:
+ main()
+ except KeyboardInterrupt:
+ pass
diff --git a/gnuradio-examples/python/hier/usrp/Makefile.am b/gnuradio-examples/python/hier/usrp/Makefile.am
index 20a21cf667..cff19ae112 100644
--- a/gnuradio-examples/python/hier/usrp/Makefile.am
+++ b/gnuradio-examples/python/hier/usrp/Makefile.am
@@ -20,6 +20,7 @@
#
EXTRA_DIST = \
- usrp_fft.py
+ usrp_fft.py \
+ usrp_siggen.py
MOSTLYCLEANFILES = *.pyc *~
diff --git a/gnuradio-examples/python/hier/usrp/usrp_siggen.py b/gnuradio-examples/python/hier/usrp/usrp_siggen.py
new file mode 100755
index 0000000000..28f80a822a
--- /dev/null
+++ b/gnuradio-examples/python/hier/usrp/usrp_siggen.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+
+from gnuradio import gr, gru
+from gnuradio import usrp
+from gnuradio.eng_option import eng_option
+from gnuradio import eng_notation
+from optparse import OptionParser
+import sys
+
+
+class my_graph(gr.hier_block2):
+ def __init__ (self, type, ampl, wfreq, offset, subdev_spec, interp, rf_freq):
+ # Call hierarchical block constructor
+ # Top-level blocks have no inputs or outputs
+ gr.hier_block2.__init__(self,
+ "usrp_siggen", # Block type
+ gr.io_signature(0,0,0), # Input signature
+ gr.io_signature(0,0,0)) # Output signature
+
+ # controllable values
+ self.interp = interp
+ self.waveform_type = type
+ self.waveform_ampl = ampl
+ self.waveform_freq = wfreq
+ self.waveform_offset = offset
+
+ self.u = usrp.sink_c (0, self.interp)
+
+ # determine the daughterboard subdevice we're using
+ if subdev_spec is None:
+ ubdev_spec = usrp.pick_tx_subdevice(self.u)
+ m = usrp.determine_tx_mux_value(self.u, subdev_spec)
+ self.u.set_mux(m)
+ self.subdev = usrp.selected_subdev(self.u, subdev_spec)
+ self.subdev.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
+ self.subdev.set_enable(True) # enable transmitter
+ print "Using TX d'board %s" % (self.subdev.side_and_name(),)
+
+ if not self.set_freq(rf_freq):
+ sys.stderr.write('Failed to set RF frequency\n')
+ raise SystemExit
+
+ self.define_component("usrp", self.u)
+
+ if type == gr.GR_SIN_WAVE or type == gr.GR_CONST_WAVE:
+ self.src = gr.sig_source_c (self.usb_freq (),
+ gr.GR_SIN_WAVE,
+ self.waveform_freq,
+ self.waveform_ampl,
+ self.waveform_offset)
+ self.define_component("src", self.src)
+
+ elif type == gr.GR_UNIFORM or type == gr.GR_GAUSSIAN:
+ self.src = gr.noise_source_c (gr.GR_UNIFORM,
+ self.waveform_ampl)
+ self.define_component("src", self.src)
+
+ else:
+ raise ValueError, type
+
+ # self.file_sink = gr.file_sink (gr.sizeof_gr_complex, "siggen.dat")
+ # self.define_component("file_sink", self.file_sink)
+
+ self.connect ("src", 0, "usrp", 0)
+
+
+ def usb_freq (self):
+ return self.u.dac_freq() / self.interp
+
+ def usb_throughput (self):
+ return self.usb_freq () * 4
+
+ def set_freq(self, target_freq):
+ """
+ Set the center frequency we're interested in.
+
+ @param target_freq: frequency in Hz
+ @rypte: bool
+
+ Tuning is a two step process. First we ask the front-end to
+ tune as close to the desired frequency as it can. Then we use
+ the result of that operation and our target_frequency to
+ determine the value for the digital up converter.
+ """
+ r = self.u.tune(self.subdev._which, self.subdev, target_freq)
+ if r:
+ #print "r.baseband_freq =", eng_notation.num_to_str(r.baseband_freq)
+ #print "r.dxc_freq =", eng_notation.num_to_str(r.dxc_freq)
+ #print "r.residual_freq =", eng_notation.num_to_str(r.residual_freq)
+ #print "r.inverted =", r.inverted
+ return True
+
+ return False
+
+
+
+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=100e3,
+ 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 ("-o", "--offset", type="eng_float", default=0,
+ help="set waveform offset to OFFSET [default=%default]")
+ (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
+
+ top_block = my_graph(options.type, options.amplitude, options.waveform_freq, options.offset,
+ options.tx_subdev_spec, options.interp, options.rf_freq)
+
+ runtime = gr.runtime(top_block)
+
+ try:
+ # Run forever
+ runtime.run()
+ except KeyboardInterrupt:
+ # Ctrl-C exits
+ pass
+
+if __name__ == '__main__':
+ main ()
--
cgit v1.2.3