[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Commit-gnuradio] r3541 - in gnuradio/branches/developers/trondeau/wip2:
From: |
trondeau |
Subject: |
[Commit-gnuradio] r3541 - in gnuradio/branches/developers/trondeau/wip2: gnuradio-core/src/lib/general gnuradio-core/src/python/gnuradio/blksimpl gnuradio-examples/python/gmsk2 gnuradio-examples/python/usrp |
Date: |
Thu, 14 Sep 2006 10:43:40 -0600 (MDT) |
Author: trondeau
Date: 2006-09-14 10:43:40 -0600 (Thu, 14 Sep 2006)
New Revision: 3541
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
Log:
more formatting of digital mod; adding debug info; trying to keep consistency
between files (need more checking on this); have Costas loop output its
frequency (normalized) on output 2 into flowgraph
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.cc
2006-09-14 16:43:40 UTC (rev 3541)
@@ -49,7 +49,7 @@
) throw (std::invalid_argument)
: gr_sync_block ("costas_loop_cc",
gr_make_io_signature (1, 1, sizeof (gr_complex)),
- gr_make_io_signature (1, 1, sizeof (gr_complex))),
+ gr_make_io_signature (1, 2, sizeof (gr_complex))),
d_alpha(alpha), d_beta(beta),
d_max_freq(max_freq), d_min_freq(min_freq),
d_phase(0), d_freq((max_freq+min_freq)/2),
@@ -92,6 +92,7 @@
{
const gr_complex *iptr = (gr_complex *) input_items[0];
gr_complex *optr = (gr_complex *) output_items[0];
+ gr_complex *foptr = (gr_complex*)output_items[1];
float error;
gr_complex nco_out;
@@ -104,15 +105,20 @@
d_freq = d_freq + d_beta * error;
d_phase = d_phase + d_freq + d_alpha * error;
+
while(d_phase>M_TWOPI)
d_phase -= M_TWOPI;
while(d_phase<-M_TWOPI)
d_phase += M_TWOPI;
- if (d_freq > d_max_freq)
+ if (d_freq > d_max_freq)
d_freq = d_max_freq;
else if (d_freq < d_min_freq)
d_freq = d_min_freq;
+
+ // fprintf(stderr, "Costas frequency = %f\terror = %f\n", d_freq,
error);
+ // d_freq_out << d_freq << std::endl;
+ foptr[i] = gr_complex(d_freq,0);
}
return noutput_items;
}
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/lib/general/gr_costas_loop_cc.h
2006-09-14 16:43:40 UTC (rev 3541)
@@ -26,6 +26,7 @@
#include <gr_sync_block.h>
#include <stdexcept>
+#include <fstream>
class gr_costas_loop_cc;
typedef boost::shared_ptr<gr_costas_loop_cc> gr_costas_loop_cc_sptr;
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/bpsk.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -58,44 +58,42 @@
@param debug: Print modualtion data to files?
@type debug: bool
"""
+ self.fg = fg
+ self.spb = spb
+ self.excess_bw = excess_bw
+
if not isinstance(spb, int) or spb < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
- self.spb = spb
ntaps = 11 * spb
- bits_per_symbol = self.bits_per_baud()
- arity = pow(2,bits_per_symbol)
+ arity = pow(2,self.bits_per_baud())
# turn bytes into k-bit vectors
self.bytes2chunks = \
- gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
+ gr.packed_to_unpacked_bb(self.bits_per_baud(), gr.GR_MSB_FIRST)
self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
- spb, # gain (spb since we're interpolating by spb)
+ spb, # gain (spb since we're interpolating by spb)
spb, # sampling rate
1.0, # symbol rate
- excess_bw, # excess bandwidth (roll-off factor)
+ self.excess_bw, # excess bandwidth (roll-off factor)
ntaps)
-
self.rrc_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
- # Connect
- fg.connect(self.bytes2chunks, self.chunks2symbols, self.rrc_filter)
-
if verbose:
- print "bits_per_symbol =", bits_per_symbol
+ self.verbose()
if debug:
- fg.connect(self.rrc_filter,
- gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
-
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.bytes2chunks, self.rrc_filter)
+ self.debug()
+ # Connect and Initialize base class
+ self.fg.connect(self.bytes2chunks, self.chunks2symbols,
self.rrc_filter)
+ gr.hier_block.__init__(self, self.fg, self.bytes2chunks,
self.rrc_filter)
+
def samples_per_baud(self):
return self.spb
@@ -103,6 +101,19 @@
return 1
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "RRC roll-off factor = %.2f" % self.excess_bw
+
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.bytes2chunks,
+ gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+ self.fg.connect(self.chunks2symbols,
+ gr.file_sink(gr.sizeof_gr_complex,
"chunks2symbols.dat"))
+ self.fg.connect(self.rrc_filter,
+ gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+
def arguments(self=None):
args = {'spb':2, 'excess_bw':0.3, 'gray_code':True, 'verbose':True,
'debug':False}
return args
@@ -112,15 +123,20 @@
"""
Adds modulation-specific options to the standard parser
"""
- parser.add_option("", "--excess-bw", type="float", default=0.3,
- help="set RRC excess bandwith factor
[default=%default]")
- parser.add_option("", "--no-gray-code", action="store_false",
default=True,
- help="Don't use gray coding on modulated bits
[default=%default]")
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--excess-bw", type="float", default=0.3,
+ help="set RRC excess bandwith factor
[default=%default]")
+ parser.add_option("", "--no-gray-code", action="store_false",
default=True,
+ help="Don't use gray coding on modulated bits
[default=%default]")
+ except OptionConflictError:
+ pass
add_options=staticmethod(add_options)
class bpsk_demod__coherent_detection_of_psk(gr.hier_block):
- def __init__(self, fg, spb, excess_bw, costas_alpha=0.005, gain_mu=0.05):
+ def __init__(self, fg, spb, excess_bw=0.35, costas_alpha=0.005,
gain_mu=0.05, mu=0.5,
+ gray_code=True, verbose=True, debug=False):
"""
Hierarchical block for RRC-filtered BPSK demodulation
@@ -137,14 +153,24 @@
@type costas_alphas: float
@param gain_mu:
@type gain_mu: float
+ @param gray_code: Tell modulator to Gray code the bits
+ @type gray_code: bool
+ @param verbose: Print information about modulator?
+ @type verbose: bool
+ @param debug: Print modualtion data to files?
+ @type debug: bool
"""
+
+ self.fg = fg
+ self.spb = spb
+ self.excess_bw = excess_bw
+ self.costas_alpha = costas_alpha
+ self.gain_mu = gain_mu
+
if spb < 2:
raise TypeError, "sbp must be >= 2"
- self.spb = spb
- bits_per_symbol = self.bits_per_baud()
- arity = pow(2,bits_per_symbol)
- print "bits_per_symbol =", bits_per_symbol
+ arity = pow(2,self.bits_per_baud())
# Automatic gain control
self.preamp = gr.multiply_const_cc(10e-5)
@@ -153,9 +179,9 @@
# Costas loop (carrier tracking)
# FIXME: need to decide how to handle this more generally; do we pull
it from higher layer?
costas_order = 2
- costas_alpha *= 15 # 2nd order loop needs more gain
+ self.costas_alpha *= 15 # 2nd order loop needs more gain
beta = .25 * costas_alpha * costas_alpha
- self.costas_loop = gr.costas_loop_cc(costas_alpha, beta, 0.05, -0.05,
costas_order)
+ self.costas_loop = gr.costas_loop_cc(self.costas_alpha, beta, 0.05,
-0.05, costas_order)
# RRC data filter
ntaps = 11 * spb
@@ -163,7 +189,7 @@
1.0, # gain
spb, # sampling rate
1.0, # symbol rate
- excess_bw, # excess bandwidth (roll-off factor)
+ self.excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)
@@ -173,42 +199,32 @@
gain_omega = .25 * gain_mu * gain_mu
omega_rel_limit = 0.5
mu = 0.05
- gain_mu = 0.1
+ self.gain_mu = 0.1
self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
- mu, gain_mu,
omega_rel_limit)
+ mu, self.gain_mu,
omega_rel_limit)
# find closest constellation point
#rot = .707 + .707j
rot = 1
- rotated_const = map(lambda pt: pt * rot, constellation[arity])
+ rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
print "rotated_const =", rotated_const
self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
- self.gray_decoder = gr.map_bb(gray_to_binary[arity])
+ self.gray_decoder = gr.map_bb(psk.gray_to_binary[arity])
# unpack the k bit vector into a stream of bits
- self.unpack = gr.unpack_k_bits_bb(bits_per_symbol)
+ self.unpack = gr.unpack_k_bits_bb(self.bits_per_baud())
- fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter,
self.clock_recovery,
- self.slicer, self.gray_decoder, self.unpack)
-
- # Debug sinks
- if 1:
- fg.connect(self.agc,
- gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
- fg.connect(self.costas_loop,
- gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
- fg.connect(self.rrc_filter,
- gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
- fg.connect(self.clock_recovery,
- gr.file_sink(gr.sizeof_gr_complex,
"clock_recovery.dat"))
- fg.connect(self.slicer,
- gr.file_sink(gr.sizeof_char, "slicer.dat"))
- fg.connect(self.unpack,
- gr.file_sink(gr.sizeof_char, "unpack.dat"))
+ if verbose:
+ self.verbose()
+
+ if debug:
+ self.debug()
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.preamp, self.unpack)
+ # Connect and Initialize base class
+ self.fg.connect(self.preamp, self.agc, self.costas_loop,
self.rrc_filter, \
+ self.clock_recovery, self.slicer, self.gray_decoder,
self.unpack)
+ gr.hier_block.__init__(self, self.fg, self.preamp, self.unpack)
def samples_per_baud(self):
return self.spb
@@ -217,6 +233,54 @@
return 1
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "RRC roll-off factor = %.2f" % self.excess_bw
+ print "Costas Loop alpha = %.5f" % self.costas_alpha
+ print "M&M symbol sync gain = %.5f" % self.gain_mu
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.agc,
+ gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
+ self.fg.connect(self.costas_loop,
+ gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
+ self.fg.connect(self.rrc_filter,
+ gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+ self.fg.connect(self.clock_recovery,
+ gr.file_sink(gr.sizeof_gr_complex,
"clock_recovery.dat"))
+ self.fg.connect(self.slicer,
+ gr.file_sink(gr.sizeof_char, "slicer.dat"))
+ self.fg.connect(self.gray_decoder,
+ gr.file_sink(gr.sizeof_char, "gray_decoder.dat"))
+ self.fg.connect(self.unpack,
+ gr.file_sink(gr.sizeof_char, "unpack.dat"))
+
+ def arguments(self=None):
+ args = {'spb':2, 'excess_bw':0.3, 'costas_alpha':0.005,
'gain_mu':0.05, 'mu':0.5,
+ 'gray_code':True, 'verbose':True, 'debug':False}
+ return args
+ arguments = staticmethod(arguments)
+
+ def add_options(parser):
+ """
+ Adds modulation-specific options to the standard parser
+ """
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--excess-bw", type="float", default=0.3,
+ help="set RRC excess bandwith factor
[default=%default]")
+ parser.add_option("", "--no-gray-code", action="store_false",
default=True,
+ help="Don't use gray coding on modulated bits
[default=%default]")
+ parser.add_option("", "--costas-alpha", type="float",
default=0.005,
+ help="set Costas loop alpha value
[default=%default]")
+ parser.add_option("", "--gain-mu", type="float", default=0.05,
+ help="set M&M symbol sync loop gain mu value
[default=%default]")
+ parser.add_option("", "--mu", type="float", default=0.5,
+ help="set M&M symbol sync loop mu value
[default=%default]")
+ except OptionConflictError:
+ pass
+ add_options=staticmethod(add_options)
+
bpsk_demod = bpsk_demod__coherent_detection_of_psk
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dbpsk.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -59,19 +59,20 @@
@type debug: bool
"""
- if not isinstance(spb, int) or spb < 2:
- raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
+ self.fg = fg
self.spb = spb
+ self.excess_bw = excess_bw
+
+ if not isinstance(self.spb, int) or self.spb < 2:
+ raise TypeError, ("sbp must be an integer >= 2, is %d" % self.spb)
- ntaps = 11 * spb
+ ntaps = 11 * self.spb
- bits_per_symbol = self.bits_per_baud()
- arity = pow(2,bits_per_symbol)
- self.bits_per_symbol = bits_per_symbol
+ arity = pow(2,self.bits_per_baud())
# turn bytes into k-bit vectors
self.bytes2chunks = \
- gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
+ gr.packed_to_unpacked_bb(self.bits_per_baud(), gr.GR_MSB_FIRST)
if gray_code:
self.gray_coder = gr.map_bb(psk.binary_to_gray[arity])
@@ -84,29 +85,26 @@
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
- spb, # gain (spb since we're interpolating by spb)
- spb, # sampling rate
- 1.0, # symbol rate
- excess_bw, # excess bandwidth (roll-off factor)
+ self.spb, # gain (spb since we're interpolating by spb)
+ self.spb, # sampling rate
+ 1.0, # symbol rate
+ self.excess_bw, # excess bandwidth (roll-off factor)
ntaps)
- self.rrc_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
+ self.rrc_filter = gr.interp_fir_filter_ccf(self.spb, self.rrc_taps)
# Connect
fg.connect(self.bytes2chunks, self.gray_coder, self.diffenc,
self.chunks2symbols, self.rrc_filter)
if verbose:
- print "bits_per_symbol =", bits_per_symbol
-
+ self.verbose()
+
if debug:
- fg.connect(self.gray_coder,
- gr.file_sink(gr.sizeof_char, "graycoder.dat"))
- fg.connect(self.diffenc,
- gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+ self.debug()
# Initialize base class
- gr.hier_block.__init__(self, fg, self.bytes2chunks, self.rrc_filter)
+ gr.hier_block.__init__(self, self.fg, self.bytes2chunks,
self.rrc_filter)
def samples_per_baud(self):
return self.spb
@@ -115,6 +113,23 @@
return 1
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "RRC roll-off factor = %.2f" % self.excess_bw
+
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.bytes2chunks,
+ gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+ self.fg.connect(self.gray_coder,
+ gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+ self.fg.connect(self.diffenc,
+ gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+ self.fg.connect(self.chunks2symbols,
+ gr.file_sink(gr.sizeof_gr_complex,
"chunks2symbols.dat"))
+ self.fg.connect(self.rrc_filter,
+ gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+
def arguments(self=None):
args = {'spb':2, 'excess_bw':0.3, 'gray_code':True, 'verbose':True,
'debug':False}
return args
@@ -124,15 +139,20 @@
"""
Adds modulation-specific options to the standard parser
"""
- parser.add_option("", "--excess-bw", type="float", default=0.3,
- help="set RRC excess bandwith factor
[default=%default]")
- parser.add_option("", "--no-gray-code", action="store_false",
default=True,
- help="Don't use gray coding on modulated bits
[default=%default]")
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--excess-bw", type="float", default=0.3,
+ help="set RRC excess bandwith factor
[default=%default]")
+ parser.add_option("", "--no-gray-code", action="store_false",
default=True,
+ help="Don't use gray coding on modulated bits
[default=%default]")
+ except OptionConflictError:
+ pass
add_options=staticmethod(add_options)
class
dbpsk_demod__coherent_detection_of_differentially_encoded_psk(gr.hier_block):
- def __init__(self, fg, spb, excess_bw, costas_alpha=0.005, gain_mu=0.05):
+ def __init__(self, fg, spb, excess_bw=0.35, costas_alpha=0.005,
gain_mu=0.05, mu=0.5,
+ gray_code=True, verbose=True, debug=False):
"""
Hierarchical block for RRC-filtered BPSK demodulation
@@ -149,14 +169,24 @@
@type costas_alphas: float
@param gain_mu:
@type gain_mu: float
+ @param gray_code: Tell modulator to Gray code the bits
+ @type gray_code: bool
+ @param verbose: Print information about modulator?
+ @type verbose: bool
+ @param debug: Print modualtion data to files?
+ @type debug: bool
"""
+
+ self.fg = fg
+ self.spb = spb
+ self.excess_bw = excess_bw
+ self.costas_alpha = costas_alpha
+ self.gain_mu = gain_mu
+
if spb < 2:
- raise TypeError, "sbp must be >= 2"
- self.spb = spb
+ raise TypeError, "sbp must be >= 2, is %d" % sbp
- bits_per_symbol = self.bits_per_baud()
- arity = pow(2,bits_per_symbol)
- print "bits_per_symbol =", bits_per_symbol
+ arity = pow(2,self.bits_per_baud())
# Automatic gain control
self.preamp = gr.multiply_const_cc(10e-5)
@@ -165,72 +195,58 @@
# Costas loop (carrier tracking)
# FIXME: need to decide how to handle this more generally; do we pull
it from higher layer?
costas_order = 2
- costas_alpha *= 15 # 2nd order loop needs more gain
+ self.costas_alpha *= 15 # 2nd order loop needs more gain
beta = .25 * costas_alpha * costas_alpha
- self.costas_loop = gr.costas_loop_cc(costas_alpha, beta, 0.05, -0.05,
costas_order)
+ self.costas_loop = gr.costas_loop_cc(self.costas_alpha, beta, 0.5,
-0.5, costas_order)
# RRC data filter
- ntaps = 11 * spb
+ ntaps = 11 * self.spb
self.rrc_taps = gr.firdes.root_raised_cosine(
1.0, # gain
spb, # sampling rate
1.0, # symbol rate
- excess_bw, # excess bandwidth (roll-off factor)
+ self.excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)
# symbol clock recovery
omega = spb
- gain_omega = .25 * gain_mu * gain_mu
+ gain_omega = .25 * self.gain_mu * self.gain_mu
omega_rel_limit = 0.5
mu = 0.05
- gain_mu = 0.1
self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
- mu, gain_mu,
omega_rel_limit)
+ mu, self.gain_mu,
+ omega_rel_limit)
# find closest constellation point
#rot = .707 + .707j
rot = 1
- rotated_const = map(lambda pt: pt * rot, constellation[arity])
+ rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
print "rotated_const =", rotated_const
self.diffdec = gr.diff_phasor_cc()
#self.diffdec = gr.diff_decoder_bb(arity)
self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
- self.gray_decoder = gr.map_bb(gray_to_binary[arity])
+ self.gray_decoder = gr.map_bb(psk.gray_to_binary[arity])
# unpack the k bit vector into a stream of bits
- self.unpack = gr.unpack_k_bits_bb(bits_per_symbol)
+ self.unpack = gr.unpack_k_bits_bb(self.bits_per_baud())
- fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter,
self.clock_recovery,
- self.diffdec, self.slicer, self.gray_decoder, self.unpack)
- #fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter,
self.clock_recovery,
+ if verbose:
+ self.verbose()
+
+ if debug:
+ self.debug()
+
+ # Connect and Initialize base class
+ self.fg.connect(self.preamp, self.agc, self.costas_loop,
self.rrc_filter, self.clock_recovery,
+ self.diffdec, self.slicer, self.gray_decoder,
self.unpack)
+ #self.fg.connect(self.preamp, self.agc, self.costas_loop,
self.rrc_filter, self.clock_recovery,
# self.slicer, self.diffdec, self.gray_decoder, self.unpack)
-
- # Debug sinks
- if 1:
- fg.connect(self.agc,
- gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
- fg.connect(self.costas_loop,
- gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
- fg.connect(self.rrc_filter,
- gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
- fg.connect(self.clock_recovery,
- gr.file_sink(gr.sizeof_gr_complex,
"clock_recovery.dat"))
- fg.connect(self.slicer,
- gr.file_sink(gr.sizeof_char, "slicer.dat"))
- fg.connect(self.diffdec,
- gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))
- #fg.connect(self.diffdec,
- # gr.file_sink(gr.sizeof_char, "diffdec.dat"))
- fg.connect(self.unpack,
- gr.file_sink(gr.sizeof_char, "unpack.dat"))
+ gr.hier_block.__init__(self, self.fg, self.preamp, self.unpack)
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.preamp, self.unpack)
-
def samples_per_baud(self):
return self.spb
@@ -238,6 +254,59 @@
return 1
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "RRC roll-off factor = %.2f" % self.excess_bw
+ print "Costas Loop alpha = %.5f" % self.costas_alpha
+ print "M&M symbol sync gain = %.5f" % self.gain_mu
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.agc,
+ gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
+ self.fg.connect(self.costas_loop,
+ gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
+ self.fg.connect(self.rrc_filter,
+ gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+ self.fg.connect(self.clock_recovery,
+ gr.file_sink(gr.sizeof_gr_complex,
"clock_recovery.dat"))
+ self.fg.connect(self.diffdec,
+ gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))
+ self.fg.connect(self.slicer,
+ gr.file_sink(gr.sizeof_char, "slicer.dat"))
+ self.fg.connect(self.gray_decoder,
+ gr.file_sink(gr.sizeof_char, "gray_decoder.dat"))
+ self.fg.connect(self.unpack,
+ gr.file_sink(gr.sizeof_char, "unpack.dat"))
+ self.fg.connect((self.costas_loop,1),
+ gr.file_sink(gr.sizeof_gr_complex, "costas.dat"))
+
+
+ def arguments(self=None):
+ args = {'spb':2, 'excess_bw':0.3, 'costas_alpha':0.005,
'gain_mu':0.05, 'mu':0.5,
+ 'gray_code':True, 'verbose':True, 'debug':False}
+ return args
+ arguments = staticmethod(arguments)
+
+ def add_options(parser):
+ """
+ Adds modulation-specific options to the standard parser
+ """
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--excess-bw", type="float", default=0.3,
+ help="set RRC excess bandwith factor
[default=%default]")
+ parser.add_option("", "--no-gray-code", action="store_false",
default=True,
+ help="Don't use gray coding on modulated bits
[default=%default]")
+ parser.add_option("", "--costas-alpha", type="float",
default=0.005,
+ help="set Costas loop alpha value
[default=%default]")
+ parser.add_option("", "--gain-mu", type="float", default=0.05,
+ help="set M&M symbol sync loop gain mu value
[default=%default]")
+ parser.add_option("", "--mu", type="float", default=0.5,
+ help="set M&M symbol sync loop mu value
[default=%default]")
+ except OptionConflictError:
+ pass
+ add_options=staticmethod(add_options)
+
dbpsk_demod = dbpsk_demod__coherent_detection_of_differentially_encoded_psk
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/dqpsk.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -58,19 +58,21 @@
@param debug: Print modualtion data to files?
@type debug: bool
"""
-
+
+ self.fg = fg
+ self.spb = spb
+ self.excess_bw = excess_bw
+
if not isinstance(spb, int) or spb < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
- self.spb = spb
ntaps = 11 * spb
+
+ arity = pow(2,self.bits_per_baud())
- bits_per_symbol = self.bits_per_baud()
- arity = pow(2,bits_per_symbol)
-
# turn bytes into k-bit vectors
self.bytes2chunks = \
- gr.packed_to_unpacked_bb(bits_per_symbol, gr.GR_MSB_FIRST)
+ gr.packed_to_unpacked_bb(self.bits_per_baud(), gr.GR_MSB_FIRST)
if gray_code:
self.gray_coder = gr.map_bb(psk.binary_to_gray[arity])
@@ -91,21 +93,16 @@
self.rrc_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
- # Connect
- fg.connect(self.bytes2chunks, self.gray_coder, self.diffenc,
- self.chunks2symbols, self.rrc_filter)
-
if verbose:
- print "bits_per_symbol =", bits_per_symbol
+ self.verbose()
if debug:
- fg.connect(self.gray_coder,
- gr.file_sink(gr.sizeof_char, "graycoder.dat"))
- fg.connect(self.diffenc,
- gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+ self.debug()
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.bytes2chunks, self.rrc_filter)
+ # Connect & Initialize base class
+ self.fg.connect(self.bytes2chunks, self.gray_coder, self.diffenc,
+ self.chunks2symbols, self.rrc_filter)
+ gr.hier_block.__init__(self, self.fg, self.bytes2chunks,
self.rrc_filter)
def samples_per_baud(self):
return self.spb
@@ -114,6 +111,23 @@
return 2
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "RRS roll-off factor = %f" % self.excess_bw
+
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.bytes2chunks,
+ gr.file_sink(gr.sizeof_char, "bytes2chunks.dat"))
+ self.fg.connect(self.gray_coder,
+ gr.file_sink(gr.sizeof_char, "graycoder.dat"))
+ self.fg.connect(self.diffenc,
+ gr.file_sink(gr.sizeof_char, "diffenc.dat"))
+ self.fg.connect(self.chunks2symbols,
+ gr.file_sink(gr.sizeof_gr_complex,
"chunks2symbols.dat"))
+ self.fg.connect(self.rrc_filter,
+ gr.file_sink(gr.sizeof_gr_complex, "rrc_filter.dat"))
+
def arguments(self=None):
args = {'spb':2, 'excess_bw':0.3, 'gray_code':True, 'verbose':True,
'debug':False}
return args
@@ -123,15 +137,20 @@
"""
Adds modulation-specific options to the standard parser
"""
- parser.add_option("", "--excess-bw", type="float", default=0.3,
- help="set RRC excess bandwith factor
[default=%default]")
- parser.add_option("", "--no-gray-code", action="store_false",
default=True,
- help="Don't use gray coding on modulated bits
[default=%default]")
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--excess-bw", type="float", default=0.3,
+ help="set RRC excess bandwith factor
[default=%default]")
+ parser.add_option("", "--no-gray-code", action="store_false",
default=True,
+ help="Don't use gray coding on modulated bits
[default=%default]")
+ except OptionConflictError:
+ pass
add_options=staticmethod(add_options)
class
dqpsk_demod__coherent_detection_of_differentially_encoded_psk(gr.hier_block):
- def __init__(self, fg, spb, excess_bw, costas_alpha=0.005, gain_mu=0.05):
+ def __init__(self, fg, spb, excess_bw=0.35, costas_alpha=0.005,
gain_mu=0.05, mu=0.5,
+ gray_code=True, verbose=True, debug=False):
"""
Hierarchical block for RRC-filtered QPSK demodulation
@@ -148,15 +167,25 @@
@type costas_alphas: float
@param gain_mu:
@type gain_mu: float
+ @param gray_code: Tell modulator to Gray code the bits
+ @type gray_code: bool
+ @param verbose: Print information about modulator?
+ @type verbose: bool
+ @param debug: Print modualtion data to files?
+ @type debug: bool
"""
- if spb < 2:
- raise TypeError, "sbp must be >= 2"
+
+ self.fg = fg
self.spb = spb
+ self.excess_bw = excess_bw
+ self.costas_alpha = costas_alpha
+ self.gain_mu = gain_mu
- bits_per_symbol = self.bits_per_baud()
- arity = pow(2,bits_per_symbol)
- print "bits_per_symbol =", bits_per_symbol
+ if spb < 2:
+ raise TypeError, "sbp must be >= 2, is %d" % spb
+ arity = pow(2,self.bits_per_baud())
+
# Automatic gain control
self.preamp = gr.multiply_const_cc(10e-5)
self.agc = gr.agc_cc(1e-3, 1, 1)
@@ -164,8 +193,8 @@
# Costas loop (carrier tracking)
# FIXME: need to decide how to handle this more generally; do we pull
it from higher layer?
costas_order = 4
- beta = .25 * costas_alpha * costas_alpha
- self.costas_loop = gr.costas_loop_cc(costas_alpha, beta, 0.05, -0.05,
costas_order)
+ beta = .25 * self.costas_alpha * self.costas_alpha
+ self.costas_loop = gr.costas_loop_cc(self.costas_alpha, beta, 0.1,
-0.1, costas_order)
# RRC data filter
ntaps = 11 * spb
@@ -185,50 +214,37 @@
mu = 0.05
gain_mu = 0.1
self.clock_recovery=gr.clock_recovery_mm_cc(omega, gain_omega,
- mu, gain_mu,
omega_rel_limit)
+ mu, self.gain_mu,
+ omega_rel_limit)
# find closest constellation point
#rot = .707 + .707j
rot = 1
- rotated_const = map(lambda pt: pt * rot, constellation[arity])
- print "rotated_const =", rotated_const
+ rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
+ print "rotated_const = %s" % rotated_const
self.diffdec = gr.diff_phasor_cc()
#self.diffdec = gr.diff_decoder_bb(arity)
self.slicer = gr.constellation_decoder_cb(rotated_const, range(arity))
- self.gray_decoder = gr.map_bb(gray_to_binary[arity])
+ self.gray_decoder = gr.map_bb(psk.gray_to_binary[arity])
# unpack the k bit vector into a stream of bits
- self.unpack = gr.unpack_k_bits_bb(bits_per_symbol)
+ self.unpack = gr.unpack_k_bits_bb(self.bits_per_baud())
- fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter,
self.clock_recovery,
- self.diffdec, self.slicer, self.gray_decoder, self.unpack)
- #fg.connect(self.preamp, self.agc, self.costas_loop, self.rrc_filter,
self.clock_recovery,
+ if verbose:
+ self.verbose()
+
+ if debug:
+ self.debug()
+
+ # Connect & Initialize base class
+ self.fg.connect(self.preamp, self.agc, self.costas_loop,
self.rrc_filter, self.clock_recovery,
+ self.diffdec, self.slicer, self.gray_decoder,
self.unpack)
+ #self.fg.connect(self.preamp, self.agc, self.costas_loop,
self.rrc_filter, self.clock_recovery,
# self.slicer, self.diffdec, self.gray_decoder, self.unpack)
-
- # Debug sinks
- if 1:
- fg.connect(self.agc,
- gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
- fg.connect(self.costas_loop,
- gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
- fg.connect(self.rrc_filter,
- gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
- fg.connect(self.clock_recovery,
- gr.file_sink(gr.sizeof_gr_complex,
"clock_recovery.dat"))
- fg.connect(self.slicer,
- gr.file_sink(gr.sizeof_char, "slicer.dat"))
- fg.connect(self.diffdec,
- gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))
- #fg.connect(self.diffdec,
- # gr.file_sink(gr.sizeof_char, "diffdec.dat"))
- fg.connect(self.unpack,
- gr.file_sink(gr.sizeof_char, "unpack.dat"))
+ gr.hier_block.__init__(self, self.fg, self.preamp, self.unpack)
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.preamp, self.unpack)
-
def samples_per_baud(self):
return self.spb
@@ -236,6 +252,58 @@
return 2
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "RRC roll-off factor = %.2f" % self.excess_bw
+ print "Costas Loop alpha = %.5f" % self.costas_alpha
+ print "M&M symbol sync gain = %.5f" % self.gain_mu
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.agc,
+ gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
+ self.fg.connect(self.costas_loop,
+ gr.file_sink(gr.sizeof_gr_complex, "costas_loop.dat"))
+ self.fg.connect(self.rrc_filter,
+ gr.file_sink(gr.sizeof_gr_complex, "rrc.dat"))
+ self.fg.connect(self.clock_recovery,
+ gr.file_sink(gr.sizeof_gr_complex,
"clock_recovery.dat"))
+ self.fg.connect(self.diffdec,
+ gr.file_sink(gr.sizeof_gr_complex, "diffdec.dat"))
+ self.fg.connect(self.slicer,
+ gr.file_sink(gr.sizeof_char, "slicer.dat"))
+ self.fg.connect(self.gray_decoder,
+ gr.file_sink(gr.sizeof_char, "gray_decoder.dat"))
+ self.fg.connect(self.unpack,
+ gr.file_sink(gr.sizeof_char, "unpack.dat"))
+ self.fg.connect((self.costas_loop,1),
+ gr.file_sink(gr.sizeof_gr_complex, "costas.dat"))
+
+ def arguments(self=None):
+ args = {'spb':2, 'excess_bw':0.3, 'costas_alpha':0.005,
'gain_mu':0.05, 'mu':0.5
+ 'gray_code':True, verbose':True, 'debug':False}
+ return args
+ arguments = staticmethod(arguments)
+
+ def add_options(parser):
+ """
+ Adds modulation-specific options to the standard parser
+ """
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--excess-bw", type="float", default=0.3,
+ help="set RRC excess bandwith factor
[default=%default]")
+ parser.add_option("", "--no-gray-code", action="store_false",
default=True,
+ help="Don't use gray coding on modulated bits
[default=%default]")
+ parser.add_option("", "--costas-alpha", type="float",
default=0.005,
+ help="set Costas loop alpha value
[default=%default]")
+ parser.add_option("", "--gain-mu", type="float", default=0.05,
+ help="set M&M symbol sync loop gain mu value
[default=%default]")
+ parser.add_option("", "--mu", type="float", default=0.5,
+ help="set M&M symbol sync loop mu value
[default=%default]")
+ except OptionConflictError:
+ pass
+ add_options=staticmethod(add_options)
+
dqpsk_demod = dqpsk_demod__coherent_detection_of_differentially_encoded_psk
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/gmsk.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -54,10 +54,12 @@
@type debug: bool
"""
- print spb
+ self.fg = fg
+ self.spb = spb
+ self.bt = bt
+
if not isinstance(spb, int) or spb < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % spb)
- self.spb = spb
ntaps = 4 * spb # up to 3 bits in filter at once
sensitivity = (pi / 2) / spb # phase change per bit = pi / 2
@@ -66,7 +68,6 @@
self.nrz = gr.bytes_to_syms()
# Form Gaussian filter
-
# Generate Gaussian response (Needs to be convolved with window below).
self.gaussian_taps = gr.firdes.gaussian(
1, # gain
@@ -82,20 +83,15 @@
# FM modulation
self.fmmod = gr.frequency_modulator_fc(sensitivity)
- # Connect
- fg.connect(self.nrz, self.gaussian_filter, self.fmmod)
-
if verbose:
- pass # I have nothing to say...
+ self.verbose()
if debug:
- fg.connect(self.gaussian_filter,
- gr.file_sink(gr.sizeof_gr_complex,
"gaussianfilter.dat"))
- fg.connect(self.diffenc,
- gr.file_sink(gr.sizeof_gr_complex, "gmsk_mod.dat"))
+ self.debug()
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.nrz, self.fmmod)
+ # Connect & Initialize base class
+ self.fg.connect(self.nrz, self.gaussian_filter, self.fmmod)
+ gr.hier_block.__init__(self, self.fg, self.nrz, self.fmmod)
def samples_per_baud(self):
return self.spb
@@ -104,6 +100,19 @@
return 1
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "Gaussian filter bt = %.2f" % self.bt
+
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.nrz,
+ gr.file_sink(gr.sizeof_float, "nrz.dat"))
+ self.fg.connect(self.gaussian_filter,
+ gr.file_sink(gr.sizeof_float, "gaussian_filter.dat"))
+ self.fg.connect(self.fmmod,
+ gr.file_sink(gr.sizeof_gr_complex, "fmmod.dat"))
+
def arguments(self=None):
args = {'spb':2, 'bt':0.3, 'verbose':True, 'debug':False}
return args
@@ -113,15 +122,20 @@
"""
Adds modulation-specific options to the standard parser
"""
- parser.add_option("", "--bt", type="float", default=0.3,
- help="set bandwidth-time product [default=%default]")
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--bt", type="float", default=0.3,
+ help="set bandwidth-time product
[default=%default]")
+ except OptionConflictError:
+ pass
add_options=staticmethod(add_options)
class gmsk_demod(gr.hier_block):
def __init__(self, fg, spb=2, omega=None, gain_mu=0.03, mu=0.5,
- omega_relative_limit=0.000200, freq_error=0.0):
+ omega_relative_limit=0.000200, freq_error=0.0,
+ verbose=True, debug=False):
"""
Hierarchical block for Gaussian Minimum Shift Key (GMSK)
demodulation.
@@ -133,6 +147,10 @@
@type fg: flow graph
@param spb: samples per baud
@type spb: integer
+ @param verbose: Print information about modulator?
+ @type verbose: bool
+ @param debug: Print modualtion data to files?
+ @type debug: bool
Clock recovery parameters. These all have reasonble defaults.
@@ -147,15 +165,23 @@
@param freq_error: bit rate error as a fraction
@param float
"""
- if spb < 2:
- raise TypeError, "sbp >= 2"
+
+ self.fg = fg
self.spb = spb
+ self.omega = omega
+ self.gain_mu = gain_mu
+ self.mu = mu
+ self.omega_relative_limit = omega_relative_limit
+ self.freq_error = freq_error
- if omega is None:
- omega = spb*(1+freq_error)
+ if spb < 2:
+ raise TypeError, "sbp >= 2, is %f" % spb
- gain_omega = .25*gain_mu*gain_mu # critically damped
+ if self.omega is None:
+ self.omega = spb*(1+self.freq_error)
+ self.gain_omega = .25*self.gain_mu*self.gain_mu # critically
damped
+
# Automatic gain control
self.preamp = gr.multiply_const_cc(10e-5)
self.agc = gr.agc_cc(1e-3, 1, 1, 1000)
@@ -164,24 +190,74 @@
sensitivity = (pi / 2) / spb
self.fmdemod = gr.quadrature_demod_cf(1.0 / sensitivity)
- alpha = 0.0008
-
# the clock recovery block tracks the symbol clock and resamples as
needed.
# the output of the block is a stream of soft symbols (float)
- self.clock_recovery = gr.clock_recovery_mm_ff(omega, gain_omega, mu,
gain_mu,
- omega_relative_limit)
+ self.clock_recovery = gr.clock_recovery_mm_ff(self.omega,
self.gain_omega,
+ self.mu, self.gain_mu,
+
self.omega_relative_limit)
# slice the floats at 0, outputting 1 bit (the LSB of the output byte)
per sample
self.slicer = gr.binary_slicer_fb()
- fg.connect(self.preamp, self.agc, self.fmdemod, self.clock_recovery,
self.slicer)
-
- # Initialize base class
- gr.hier_block.__init__(self, fg, self.preamp, self.slicer)
+ if verbose:
+ self.verbose()
+
+ if debug:
+ self.debug()
+ # Connect & Initialize base class
+ self.fg.connect(self.preamp, self.agc, self.fmdemod,
self.clock_recovery, self.slicer)
+ gr.hier_block.__init__(self, self.fg, self.preamp, self.slicer)
+
def samples_per_baud(self):
return self.spb
def bits_per_baud(self=None): # staticmethod that's also callable on an
instance
return 1
bits_per_baud = staticmethod(bits_per_baud) # make it a static
method. RTFM
+
+ def verbose(self):
+ print "bits per symbol = %d" % self.bits_per_baud()
+ print "M&M clock recovery omega = %f" % self.omega
+ print "M&M clock recovery gain mu = %f" % self.gain_mu
+ print "M&M clock recovery mu = %f" % self.mu
+ print "M&M clock recovery omega rel. limit = %f" %
self.omega_relative_limit
+ print "frequency error = %f" % self.freq_error
+
+ def debug(self):
+ print "Modulation debugging turned on."
+ self.fg.connect(self.agc,
+ gr.file_sink(gr.sizeof_gr_complex, "agc.dat"))
+ self.fg.connect(self.fmdemod,
+ gr.file_sink(gr.sizeof_float, "fmdemod.dat"))
+ self.fg.connect(self.clock_recovery,
+ gr.file_sink(gr.sizeof_float, "clock_recovery.dat"))
+ self.fg.connect(self.slicer,
+ gr.file_sink(gr.sizeof_char, "slicer.dat"))
+
+ def arguments(self=None):
+ args = {'spb':2, 'omega':None, 'gain_mu':0.03, 'mu':0.5, \
+ 'omega_relative_limit':0.0002, 'freq_error':0.0, \
+ 'verbose':True, 'debug':False}
+ return args
+ arguments = staticmethod(arguments)
+
+ def add_options(parser):
+ """
+ Adds modulation-specific options to the standard parser
+ """
+ from optparse import OptionConflictError
+ try:
+ parser.add_option("", "--omega", type="float", default=None,
+ help="M&M clock recovery omega
[default=%default]")
+ parser.add_option("", "--gain_mu", type="float", default=0.03,
+ help="M&M clock recovery gain mu
[default=%default]")
+ parser.add_option("", "--mu", type="float", default=0.5,
+ help="M&M clock recovery mu [default=%default]")
+ parser.add_option("", "--omega_relative_limit", type="float",
default=0.0002,
+ help="M&M clock recovery omega relative limit
[default=%default]")
+ parser.add_option("", "--freq_error", type="float", default=0.0,
+ help="M&M clock recovery frequency error
[default=%default]")
+ except OptionConflictError:
+ pass
+ add_options=staticmethod(add_options)
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-core/src/python/gnuradio/blksimpl/modulators.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -10,12 +10,12 @@
'gmsk': getattr(gmsk, "gmsk_mod"),
}
-demodulators = [
- getattr(bpsk, "bpsk_demod"),
- getattr(dbpsk, "dbpsk_demod"),
- getattr(dqpsk, "dqpsk_demod"),
- getattr(gmsk, "gmsk_demod"),
-]
+demodulators = {
+ 'bpsk': getattr(bpsk, "bpsk_demod"),
+ 'dbpsk': getattr(dbpsk, "dbpsk_demod"),
+ 'dqpsk': getattr(dqpsk, "dqpsk_demod"),
+ 'gmsk': getattr(gmsk, "gmsk_demod"),
+}
def kwargs(modulator, attrs):
args = modulator.arguments()
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/benchmark_rx.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -69,13 +69,15 @@
# Create Options Parser:
parser = OptionParser (option_class=eng_option)
parser.add_option("-m", "--modulation", type="choice",
choices=blks.demodulators.keys(),
- default='bpsk',
+ default='dbpsk',
help="Set modulation type %s" % blks.demodulators.keys())
mod_grp = parser.add_option_group("Modulation")
for mod in blks.demodulators.values():
mod.add_options(mod_grp)
receive_path.add_options(parser)
fusb_options.add_options(parser)
+ parser.add_option("", "--debug", action="store_true", default="False",
+ help="Turn debugging information on (CAUTION: takes up
lots of diskspace)")
(options, args) = parser.parse_args ()
if len(args) != 0:
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/receive_path.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -64,7 +64,7 @@
# Get demod_kwargs
demod_kwargs = blks.kwargs(self._demodulator, [self._spb, self._decim,
self._bitrate])
- demod_kwargs['debug']=True
+ demod_kwargs['debug']=options.debug
# receiver
self.packet_receiver = \
@@ -92,7 +92,7 @@
# Display some information about the setup
if verbose:
- self.verbosity()
+ self.verbose()
fg.connect(self.u, self.chan_filt, self.packet_receiver)
gr.hier_block.__init__(self, fg, None, None)
@@ -185,7 +185,7 @@
"""
self.probe.set_threshold(threshold_in_db)
- def verbosity(self):
+ def verbose(self):
"""
Prints information about the receive path
"""
@@ -194,7 +194,9 @@
print "bitrate: %sb/sec" % (eng_notation.num_to_str(self._bitrate))
print "spb: %3d" % (self._spb)
print "decim: %3d" % (self._decim)
- print "Center Frequency: %s" %
(eng_notation.num_to_str(self._center_freq))
+ #print "Center Frequency: %s" %
(eng_notation.num_to_str(self._center_freq))
+ print "Center Frequency: %f" % (self._center_freq)
+
def add_options(parser):
"""
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/gmsk2/transmit_path.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -62,21 +62,23 @@
# transmitter
self.packet_transmitter = \
blks.mod_pkts(fg,
- self._modulator(fg, **mod_kwargs),
+ self._modulator(fg, debug=options.debug,
**mod_kwargs),
access_code=None,
msgq_limit=4,
pad_for_usrp=True)
# Set gains: digital and USRP
self.amp = gr.multiply_const_cc(self._gain)
- self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain
+ print self.subdev.gain_range()
+ self.set_gain(self.subdev.gain_range()[0]) # set max Tx gain
+ self.set_gain(0)
# enable Auto Transmit/Receive switching
self.set_auto_tr(True)
# Display some information about the setup
if verbose:
- self.verbosity()
+ self.verbose()
# Create and setup transmit path flow graph
fg.connect(self.packet_transmitter, self.amp, self.u)
@@ -128,7 +130,7 @@
return True
return False
-
+
def set_gain(self, gain):
"""
Sets the analog gain in the USRP
@@ -157,7 +159,7 @@
def interp(self):
return self._interp
- def verbosity(self):
+ def verbose(self):
"""
Prints information about the transmit path
"""
Modified:
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
===================================================================
---
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
2006-09-14 15:09:03 UTC (rev 3540)
+++
gnuradio/branches/developers/trondeau/wip2/gnuradio-examples/python/usrp/usrp_siggen.py
2006-09-14 16:43:40 UTC (rev 3541)
@@ -146,6 +146,12 @@
parser.print_help()
raise SystemExit
+ print "FPGA Interpolation: %d" % options.interp
+ print "Waveform Type: %s" % options.type
+ print "Waveform Freq: %d" % options.freq
+ print "Waveform Ampl: %d" % options.ampl
+ print "Waveform Offs: %d" % options.offset
+
fg = my_graph()
fg.set_interpolator (options.interp)
fg.set_waveform_type (options.type)
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Commit-gnuradio] r3541 - in gnuradio/branches/developers/trondeau/wip2: gnuradio-core/src/lib/general gnuradio-core/src/python/gnuradio/blksimpl gnuradio-examples/python/gmsk2 gnuradio-examples/python/usrp,
trondeau <=