def __init__(self, constellation, differential, rotation):
if constellation.arity() > 256:
# If this becomes limiting some of the blocks should be generalised so
# that they can work with shorts and ints as well as chars.
raise ValueError("Constellation cannot contain more than 256 points.")
gr.hier_block2.__init__(self, "mod_demod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
arity = constellation.arity()
# TX
self.constellation = constellation
self.differential = differential
import weakref
self.blocks = [weakref.proxy(self)]
# We expect a stream of unpacked bits.
# First step is to pack them.
self.blocks.append(
gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST))
# Second step we unpack them such that we have k bits in each byte where
# each constellation symbol hold k bits.
self.blocks.append(
gr.packed_to_unpacked_bb(self.constellation.bits_per_symbol(),
gr.GR_MSB_FIRST))
# Apply any pre-differential coding
# Gray-coding is done here if we're also using differential coding.
if self.constellation.apply_pre_diff_code():
self.blocks.append(gr.map_bb(self.constellation.pre_diff_code()))
# Differential encoding.
if self.differential:
self.blocks.append(gr.diff_encoder_bb(arity))
# Convert to constellation symbols.
self.blocks.append(gr.chunks_to_symbols_bc(self.constellation.points(),
self.constellation.dimensionality()))
# CHANNEL
# Channel just consists of a rotation to check differential coding.
if rotation is not None:
self.blocks.append(gr.multiply_const_cc(rotation))
# RX
# Convert the constellation symbols back to binary values.
self.blocks.append(digital_swig.constellation_decoder_cb(self.constellation.base()))
# Differential decoding.
if self.differential:
self.blocks.append(gr.diff_decoder_bb(arity))
# Decode any pre-differential coding.
if self.constellation.apply_pre_diff_code():
self.blocks.append(gr.map_bb(
mod_codes.invert_code(self.constellation.pre_diff_code())))
# unpack the k bit vector into a stream of bits
self.blocks.append(gr.unpack_k_bits_bb(
self.constellation.bits_per_symbol()))
# connect to block output
check_index = len(self.blocks)
self.blocks = self.blocks[:check_index]
self.blocks.append(weakref.proxy(self))
self.connect(*self.blocks)
def __init__(self, constellation, differential, rotation):
if constellation.arity() > 256:
# If this becomes limiting some of the blocks should be generalised so
# that they can work with shorts and ints as well as chars.
raise ValueError("Constellation cannot contain more than 256 points.")
gr.hier_block2.__init__(self, "mod_demod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
arity = constellation.arity()
# TX
self.constellation = constellation
self.differential = differential
self.blocks = [self]
# We expect a stream of unpacked bits.
# First step is to pack them.
self.blocks.append(
gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST))
# Second step we unpack them such that we have k bits in each byte where
# each constellation symbol hold k bits.
self.blocks.append(
gr.packed_to_unpacked_bb(self.constellation.bits_per_symbol(),
gr.GR_MSB_FIRST))
# Apply any pre-differential coding
# Gray-coding is done here if we're also using differential coding.
if self.constellation.apply_pre_diff_code():
self.blocks.append(gr.map_bb(self.constellation.pre_diff_code()))
# Differential encoding.
if self.differential:
self.blocks.append(gr.diff_encoder_bb(arity))
# Convert to constellation symbols.
self.blocks.append(gr.chunks_to_symbols_bc(self.constellation.points(),
self.constellation.dimensionality()))
# CHANNEL
# Channel just consists of a rotation to check differential coding.
if rotation is not None:
self.blocks.append(gr.multiply_const_cc(rotation))
# RX
# Convert the constellation symbols back to binary values.
self.blocks.append(digital_swig.constellation_decoder_cb(self.constellation.base()))
# Differential decoding.
if self.differential:
self.blocks.append(gr.diff_decoder_bb(arity))
# Decode any pre-differential coding.
if self.constellation.apply_pre_diff_code():
self.blocks.append(gr.map_bb(
mod_codes.invert_code(self.constellation.pre_diff_code())))
# unpack the k bit vector into a stream of bits
self.blocks.append(gr.unpack_k_bits_bb(
self.constellation.bits_per_symbol()))
# connect to block output
check_index = len(self.blocks)
self.blocks = self.blocks[:check_index]
self.blocks.append(self)
self.connect(*self.blocks)
def test_diff_encdec_002(self):
random.seed(0)
modulus = 8
src_data = make_random_int_tuple(40000, 0, modulus-1)
expected_result = src_data
src = gr.vector_source_b(src_data)
enc = gr.diff_encoder_bb(modulus)
dec = gr.diff_decoder_bb(modulus)
dst = gr.vector_sink_b()
self.tb.connect(src, enc, dec, dst)
self.tb.run() # run the graph and wait for it to finish
actual_result = dst.data() # fetch the contents of the sink
self.assertEqual(expected_result, actual_result)
def __init__(self, fg, spb, alpha, gain, use_barker=0):
if not isinstance(spb, int) or spb < 2:
raise TypeError, "sbp must be an integer >= 2"
self.spb = spb
self.bits_per_chunk = 1
ntaps = 2 * spb - 1
alpha = 0.5
self.bytes2chunks = gr.packed_to_unpacked_bb(self.bits_per_chunk,
gr.GR_MSB_FIRST)
constellation = ( (), ( -1-0j,1+0j ), ( 0.707+0.707j,-0.707-0.707j ),
( 0.707+0j,-0.707-0.707j ), ( -1+0j,-1j, 1j, 1+0j ),
( 1+0j,0+1j,-1+0j,0-1j ), ( 0+0j,1+0j ) )
self.chunks2symbols = gr.chunks_to_symbols_bc(constellation[2])
self.scrambler = bbn.scrambler_bb(True)
self.diff_encode = gr.diff_encoder_bb(2);
self.barker_taps = bbn.firdes_barker(spb)
self.rrc_taps = gr.firdes.root_raised_cosine(4 * gain, spb,
1.0, alpha, ntaps)
if use_barker:
self.tx_filter = gr.interp_fir_filter_ccf(spb, self.barker_taps)
else:
self.tx_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
fg.connect(self.scrambler, self.bytes2chunks)
fg.connect(self.bytes2chunks, self.diff_encode)
fg.connect(self.diff_encode, self.chunks2symbols)
fg.connect(self.chunks2symbols,self.tx_filter)
gr.hier_block.__init__(self, fg, self.scrambler, self.tx_filter)
bbn.crc16_init()
def __init__(self,
samples_per_symbol=_def_samples_per_symbol,
excess_bw=_def_excess_bw,
gray_code=_def_gray_code,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered QPSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param samples_per_symbol: samples per symbol >= 2
@type samples_per_symbol: integer
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: 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
"""
gr.hier_block2.__init__(
self,
"qam8_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._gray_code = gray_code
if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" %
samples_per_symbol)
ntaps = 11 * samples_per_symbol
arity = pow(2, self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity])
else:
self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity])
self.diffenc = gr.diff_encoder_bb(arity)
rot = 1.0
print "constellation with %d arity" % arity
rotated_const = map(lambda pt: pt * rot, qam.constellation[arity])
self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
self.
_samples_per_symbol, # gain (sps since we're interpolating by sps)
self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
self.rrc_taps)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect
self.connect(self, self.bytes2chunks, self.symbol_mapper, self.diffenc,
self.chunks2symbols, self.rrc_filter, self)
def __init__(self, constellation,
samples_per_symbol=_def_samples_per_symbol,
differential=_def_differential,
excess_bw=_def_excess_bw,
gray_coded=True,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered differential generic modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param constellation: determines the modulation type
@type constellation: gnuradio.digital.gr_constellation
@param samples_per_symbol: samples per baud >= 2
@type samples_per_symbol: float
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: float
@param gray_coded: turn gray coding on/off
@type gray_coded: bool
@param verbose: Print information about modulator?
@type verbose: bool
@param log: Log modulation data to files?
@type log: bool
"""
gr.hier_block2.__init__(self, "generic_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._constellation = constellation.base()
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._differential = differential
if self._samples_per_symbol < 2:
raise TypeError, ("sbp must be >= 2, is %f" % self._samples_per_symbol)
arity = pow(2,self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if gray_coded == True:
self.symbol_mapper = gr.map_bb(self._constellation.pre_diff_code())
if differential:
self.diffenc = gr.diff_encoder_bb(arity)
self.chunks2symbols = gr.chunks_to_symbols_bc(self._constellation.points())
# pulse shaping filter
nfilts = 32
ntaps = nfilts * 11 * int(self._samples_per_symbol) # make nfilts filters of ntaps each
self.rrc_taps = gr.firdes.root_raised_cosine(
nfilts, # gain
nfilts, # sampling rate based on 32 filters in resampler
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.pfb_arb_resampler_ccf(self._samples_per_symbol,
self.rrc_taps)
# Connect
blocks = [self, self.bytes2chunks]
if gray_coded == True:
blocks.append(self.symbol_mapper)
if differential:
blocks.append(self.diffenc)
blocks += [self.chunks2symbols, self.rrc_filter, self]
self.connect(*blocks)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Rds Tx")
_icon_path = "/home/azimout/.local/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.usrp_interp = usrp_interp = 500
self.dac_rate = dac_rate = 128e6
self.wav_rate = wav_rate = 44100
self.usrp_rate = usrp_rate = int(dac_rate/usrp_interp)
self.fm_max_dev = fm_max_dev = 120e3
##################################################
# Blocks
##################################################
self.band_pass_filter_0 = gr.interp_fir_filter_fff(1, firdes.band_pass(
1, usrp_rate, 54e3, 60e3, 3e3, firdes.WIN_HAMMING, 6.76))
self.band_pass_filter_1 = gr.interp_fir_filter_fff(1, firdes.band_pass(
1, usrp_rate, 23e3, 53e3, 2e3, firdes.WIN_HAMMING, 6.76))
self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff(
interpolation=usrp_rate,
decimation=wav_rate,
taps=None,
fractional_bw=None,
)
self.blks2_rational_resampler_xxx_1_0 = blks2.rational_resampler_fff(
interpolation=usrp_rate,
decimation=wav_rate,
taps=None,
fractional_bw=None,
)
self.gr_add_xx_0 = gr.add_vff(1)
self.gr_add_xx_1 = gr.add_vff(1)
self.gr_char_to_float_0 = gr.char_to_float()
self.gr_diff_encoder_bb_0 = gr.diff_encoder_bb(2)
self.gr_frequency_modulator_fc_0 = gr.frequency_modulator_fc(2*math.pi*fm_max_dev/usrp_rate)
self.gr_map_bb_0 = gr.map_bb(([-1,1]))
self.gr_map_bb_1 = gr.map_bb(([1,2]))
self.gr_multiply_xx_0 = gr.multiply_vff(1)
self.gr_multiply_xx_1 = gr.multiply_vff(1)
self.gr_rds_data_encoder_0 = rds.data_encoder("/media/dimitris/mywork/gr/dimitris/rds/trunk/src/test/rds_data.xml")
self.gr_rds_rate_enforcer_0 = rds.rate_enforcer(256000)
self.gr_sig_source_x_0 = gr.sig_source_f(usrp_rate, gr.GR_COS_WAVE, 19e3, 0.3, 0)
self.gr_sub_xx_0 = gr.sub_ff(1)
self.gr_unpack_k_bits_bb_0 = gr.unpack_k_bits_bb(2)
self.gr_wavfile_source_0 = gr.wavfile_source("/media/dimitris/mywork/gr/dimitris/rds/trunk/src/python/limmenso_stereo.wav", True)
self.low_pass_filter_0 = gr.interp_fir_filter_fff(1, firdes.low_pass(
1, usrp_rate, 1.5e3, 2e3, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0_0 = gr.interp_fir_filter_fff(1, firdes.low_pass(
1, usrp_rate, 15e3, 2e3, firdes.WIN_HAMMING, 6.76))
self.usrp_simple_sink_x_0 = grc_usrp.simple_sink_c(which=0, side="A")
self.usrp_simple_sink_x_0.set_interp_rate(500)
self.usrp_simple_sink_x_0.set_frequency(107.2e6, verbose=True)
self.usrp_simple_sink_x_0.set_gain(0)
self.usrp_simple_sink_x_0.set_enable(True)
self.usrp_simple_sink_x_0.set_auto_tr(True)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_f(
self.GetWin(),
baseband_freq=0,
y_per_div=20,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=usrp_rate,
fft_size=1024,
fft_rate=30,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
##################################################
# Connections
##################################################
self.connect((self.gr_sig_source_x_0, 0), (self.gr_rds_rate_enforcer_0, 1))
self.connect((self.gr_char_to_float_0, 0), (self.gr_rds_rate_enforcer_0, 0))
self.connect((self.gr_map_bb_0, 0), (self.gr_char_to_float_0, 0))
self.connect((self.gr_frequency_modulator_fc_0, 0), (self.usrp_simple_sink_x_0, 0))
self.connect((self.gr_add_xx_1, 0), (self.gr_frequency_modulator_fc_0, 0))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_add_xx_1, 1))
self.connect((self.gr_sub_xx_0, 0), (self.gr_multiply_xx_1, 2))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_1, 1))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_1, 0))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 3))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 2))
self.connect((self.blks2_rational_resampler_xxx_1_0, 0), (self.gr_add_xx_0, 1))
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.gr_add_xx_0, 0))
self.connect((self.blks2_rational_resampler_xxx_1_0, 0), (self.gr_sub_xx_0, 1))
self.connect((self.blks2_rational_resampler_xxx_1, 0), (self.gr_sub_xx_0, 0))
self.connect((self.gr_wavfile_source_0, 1), (self.blks2_rational_resampler_xxx_1_0, 0))
self.connect((self.gr_wavfile_source_0, 0), (self.blks2_rational_resampler_xxx_1, 0))
self.connect((self.gr_rds_data_encoder_0, 0), (self.gr_diff_encoder_bb_0, 0))
self.connect((self.gr_diff_encoder_bb_0, 0), (self.gr_map_bb_1, 0))
self.connect((self.gr_map_bb_1, 0), (self.gr_unpack_k_bits_bb_0, 0))
self.connect((self.gr_unpack_k_bits_bb_0, 0), (self.gr_map_bb_0, 0))
self.connect((self.gr_rds_rate_enforcer_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.gr_multiply_xx_0, 0))
self.connect((self.gr_multiply_xx_0, 0), (self.band_pass_filter_0, 0))
self.connect((self.band_pass_filter_0, 0), (self.gr_add_xx_1, 0))
self.connect((self.gr_multiply_xx_1, 0), (self.band_pass_filter_1, 0))
self.connect((self.band_pass_filter_1, 0), (self.gr_add_xx_1, 3))
self.connect((self.gr_add_xx_1, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 1))
self.connect((self.gr_add_xx_0, 0), (self.low_pass_filter_0_0, 0))
self.connect((self.low_pass_filter_0_0, 0), (self.gr_add_xx_1, 2))
def __init__(self,
samples_per_symbol=_def_samples_per_symbol,
excess_bw=_def_excess_bw,
gray_code=_def_gray_code,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered QPSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param samples_per_symbol: samples per symbol >= 2
@type samples_per_symbol: integer
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: 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
"""
gr.hier_block2.__init__(self, "qam8_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._gray_code = gray_code
if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
ntaps = 11 * samples_per_symbol
arity = pow(2, self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
self.symbol_mapper = gr.map_bb(qam.binary_to_gray[arity])
else:
self.symbol_mapper = gr.map_bb(qam.binary_to_ungray[arity])
self.diffenc = gr.diff_encoder_bb(arity)
rot = 1.0
print "constellation with %d arity" % arity
rotated_const = map(lambda pt: pt * rot, qam.constellation[arity])
self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
self._samples_per_symbol, # gain (sps since we're interpolating by sps)
self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect
self.connect(self, self.bytes2chunks, self.symbol_mapper, self.diffenc,
self.chunks2symbols, self.rrc_filter, self)
def __init__(self,
samples_per_symbol=_def_samples_per_symbol,
excess_bw=_def_excess_bw,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered QPSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param samples_per_symbol: samples per symbol >= 2
@type samples_per_symbol: integer
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: float
@param verbose: Print information about modulator?
@type verbose: bool
@param debug: Print modualtion data to files?
@type debug: bool
"""
gr.hier_block2.__init__(self, "cqpsk_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
if not isinstance(samples_per_symbol, int) or samples_per_symbol < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % samples_per_symbol)
ntaps = 11 * samples_per_symbol
arity = 8
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
# 0 +45 1 [+1]
# 1 +135 3 [+3]
# 2 -45 7 [-1]
# 3 -135 5 [-3]
self.pi4map = [1, 3, 7, 5]
self.symbol_mapper = gr.map_bb(self.pi4map)
self.diffenc = gr.diff_encoder_bb(arity)
self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
# pulse shaping filter
self.rrc_taps = firdes.root_raised_cosine(
self._samples_per_symbol, # gain (sps since we're interpolating by sps)
self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = filter.interp_fir_filter_ccf(self._samples_per_symbol, self.rrc_taps)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect & Initialize base class
self.connect(self, self.bytes2chunks, self.symbol_mapper, self.diffenc,
self.chunks2symbols, self.rrc_filter, self)
def __init__(self, gui, options):
gr.hier_block2.__init__(self, "bpsk_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = options.sps
self.amplitude = options.amplitude
self.verbose = options.verbose
self._excess_bw = _def_excess_bw
self._gray_code = _def_gray_code
if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2:
raise TypeError, ("sample per symbol must be an integer >= 2, is %d" % self._samples_per_symbol)
arity = pow(2,self.bits_per_symbol())
# turn bytes into k-bit vectors
self.packed_to_unpacked_bb = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
else:
self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
self.diff_encoder_bb = gr.diff_encoder_bb(arity)
#This bloc allow to decode the stream
#self.scrambler = gr.scrambler_bb(0x8A, 0x7F, 7)
#Transform symbols to chips
self.symbols_to_chips = ieee.symbols_to_chips_bs()
#self.chunks2symbols = gr.chunks_to_symbols_ic(psk.constellation[arity])
self.chunks2symbols = gr.chunks_to_symbols_sc([-1+0j, 1+0j])
self.chunks2symbols_b = gr.chunks_to_symbols_bc([-1+0j, 1+0j])
# transform chips to symbols
print "bits_per_symbol", self.bits_per_symbol()
self.packed_to_unpacked_ss = \
gr.packed_to_unpacked_ss(self.bits_per_symbol(), gr.GR_MSB_FIRST)
ntaps = 11 * self._samples_per_symbol
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
self._samples_per_symbol * self.amplitude, # gain (samples_per_symbol since we're
# interpolating by samples_per_symbol)
self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
self.rrc_taps)
# Connect
#self.connect(self, self.bytes2chunks, self.symbol_mapper,self.scrambler, self.chunks2symbols, self.rrc_filter, self)
# self.wxgui_constellationsink2_0 = constsink_gl.const_sink_c(
# gui.GetWin(),
# title="Constellation Plot",
# sample_rate=self._samples_per_symbol,
# frame_rate=5,
# const_size=2048,
# M=2,
# theta=0,
# alpha=0.005,
# fmax=0.06,
# mu=0.5,
# gain_mu=0.005,
# symbol_rate=self._samples_per_symbol/2,
# omega_limit=0.005,
# )
# gui.Add(self.wxgui_constellationsink2_0.win)
#Modefied for IEEE 802.15.4
#self.connect(self, self.packed_to_unpacked_bb, self.symbol_mapper, self.diff_encoder_bb, self.symbols_to_chips, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
self.connect(self, self.packed_to_unpacked_bb, self.symbol_mapper, self.symbols_to_chips, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#self.connect(self, self.symbols_to_chips, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#self.connect(self, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#self.connect(self, self._scrambler, self.chunks2symbols_b, self.rrc_filter, self)
#self.connect(self.rrc_filter, self.wxgui_constellationsink2_0)
if self.verbose:
self._print_verbage()
def __init__(self,
samples_per_symbol=_def_samples_per_symbol,
excess_bw=_def_excess_bw,
gray_code=_def_gray_code,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered QPSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param samples_per_symbol: samples per symbol >= 2
@type samples_per_symbol: integer
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: 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
"""
gr.hier_block2.__init__(
self,
"dqpsk2_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._gray_code = gray_code
if samples_per_symbol < 2:
raise TypeError, ("sbp must be >= 2, is %f" % samples_per_symbol)
ntaps = 11 * samples_per_symbol
arity = pow(2, self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
else:
self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
self.diffenc = gr.diff_encoder_bb(arity)
rot = .707 + .707j
rotated_const = map(lambda pt: pt * rot, psk.constellation[arity])
self.chunks2symbols = gr.chunks_to_symbols_bc(rotated_const)
# pulse shaping filter
nfilts = 32
ntaps = 11 * int(
nfilts *
self._samples_per_symbol) # make nfilts filters of ntaps each
self.rrc_taps = gr.firdes.root_raised_cosine(
nfilts, # gain
nfilts, # sampling rate based on 32 filters in resampler
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.pfb_arb_resampler_ccf(self._samples_per_symbol,
self.rrc_taps)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect & Initialize base class
self.connect(self, self.bytes2chunks, self.symbol_mapper, self.diffenc,
self.chunks2symbols, self.rrc_filter, self)
def __init__(self, fg, spb, alpha, gain, use_barker=0):
"""
Hierarchical block for RRC-filtered PSK modulation
modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param fg: flow graph
@type fg: flow graph
@param spb: samples per baud >= 2
@type spb: integer
@param alpha: Root-raised cosine filter excess bandwidth
@type alpha: float
"""
if not isinstance(spb, int) or spb < 2:
raise TypeError, "sbp must be an integer >= 2"
self.spb = spb
self.bits_per_chunk = 1
ntaps = 2 * spb - 1
alpha = 0.5
# turn bytes into symbols
self.bytes2chunks = gr.packed_to_unpacked_bb(self.bits_per_chunk,
gr.GR_MSB_FIRST)
constellation = ( (),
( -1-0j,1+0j ),
( 0.707+0.707j,-0.707-0.707j ),
( 0.707+0j,-0.707-0.707j ),
( -1+0j,-1j, 1j, 1+0j),
( 1+0j,0+1j,-1+0j,0-1j ),
( 0+0j,1+0j ),
)
self.chunks2symbols = gr.chunks_to_symbols_bc(constellation[2])
self.scrambler = bbn.scrambler_bb(True)
self.diff_encode = gr.diff_encoder_bb(2);
self.barker_taps = bbn.firdes_barker(spb)
# Form Raised Cosine filter
self.rrc_taps = gr.firdes.root_raised_cosine(
4 * gain, # gain FIXME may need to be spb
spb, # sampling freq
1.0, # symbol_rate
alpha,
ntaps)
if use_barker:
self.tx_filter = gr.interp_fir_filter_ccf(spb, self.barker_taps)
else:
self.tx_filter = gr.interp_fir_filter_ccf(spb, self.rrc_taps)
# Connect
fg.connect(self.scrambler, self.bytes2chunks)
fg.connect(self.bytes2chunks, self.diff_encode)
fg.connect(self.diff_encode, self.chunks2symbols)
fg.connect(self.chunks2symbols,self.tx_filter)
# Initialize base class
gr.hier_block.__init__(self, fg, self.scrambler, self.tx_filter)
bbn.crc16_init()
def __init__(self,
constellation,
samples_per_symbol=_def_samples_per_symbol,
differential=_def_differential,
excess_bw=_def_excess_bw,
gray_coded=True,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered differential generic modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param constellation: determines the modulation type
@type constellation: gnuradio.digital.gr_constellation
@param samples_per_symbol: samples per baud >= 2
@type samples_per_symbol: float
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: float
@param gray_coded: turn gray coding on/off
@type gray_coded: bool
@param verbose: Print information about modulator?
@type verbose: bool
@param log: Log modulation data to files?
@type log: bool
"""
gr.hier_block2.__init__(
self,
"generic_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._constellation = constellation.base()
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._differential = differential
if self._samples_per_symbol < 2:
raise TypeError, ("sbp must be >= 2, is %f" %
self._samples_per_symbol)
arity = pow(2, self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if gray_coded == True:
self.symbol_mapper = gr.map_bb(self._constellation.pre_diff_code())
if differential:
self.diffenc = gr.diff_encoder_bb(arity)
self.chunks2symbols = gr.chunks_to_symbols_bc(
self._constellation.points())
# pulse shaping filter
nfilts = 32
ntaps = nfilts * 11 * int(
self._samples_per_symbol) # make nfilts filters of ntaps each
self.rrc_taps = gr.firdes.root_raised_cosine(
nfilts, # gain
nfilts, # sampling rate based on 32 filters in resampler
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.pfb_arb_resampler_ccf(self._samples_per_symbol,
self.rrc_taps)
# Connect
blocks = [self, self.bytes2chunks]
if gray_coded == True:
blocks.append(self.symbol_mapper)
if differential:
blocks.append(self.diffenc)
blocks += [self.chunks2symbols, self.rrc_filter, self]
self.connect(*blocks)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
def __init__(self, principal_gui, options):
gr.hier_block2.__init__(self, "bpsk_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = options.sps
self.amplitude = options.amplitude
self.verbose = options.verbose
self._excess_bw = _def_excess_bw
self._gray_code = _def_gray_code
if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2:
raise TypeError, ("sample per symbol must be an integer >= 2, is %d" % self._samples_per_symbol)
arity = pow(2,self.bits_per_symbol())
#arity = pow (2, 2)
# turn bytes into k-bit vectors
self.packed_to_unpacked_bb = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
map_param = psk.binary_to_gray[arity]
self.symbol_mapper = gr.map_bb(map_param)
else:
self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
self.diff_encoder_bb = gr.diff_encoder_bb(arity)
#This bloc allow to decode the stream
#self.scrambler = gr.scrambler_bb(0x8A, 0x7F, 7)
#Transform symbols to chips
self.symbols_to_chips = ieee.symbols_to_chips_bs()
#self.chunks2symbols = gr.chunks_to_symbols_ic(psk.constellation[arity])
self.chunks2symbols = gr.chunks_to_symbols_sc([-1+0j, 1+0j])
self.chunks2symbols_b = gr.chunks_to_symbols_bc([-1+0j, 1+0j])
# transform chips to symbols
print "bits_per_symbol", self.bits_per_symbol()
self.packed_to_unpacked_ss = \
gr.packed_to_unpacked_ss(self.bits_per_symbol(), gr.GR_MSB_FIRST)
ntaps = 11 * self._samples_per_symbol
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
self._samples_per_symbol, # gain (samples_per_symbol since we're
# interpolating by samples_per_symbol)
self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
self.rrc_taps)
# Connect
#self.connect(self, self.bytes2chunks, self.symbol_mapper,self.scrambler, self.chunks2symbols, self.rrc_filter, self)
#Modefied for IEEE 802.15.4
#self.connect(self, self.packed_to_unpacked_bb, self.symbol_mapper, self.diff_encoder_bb, self.symbols_to_chips, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#For IEEE 802.15.4 915 868 MHz standard
self.connect(self, self.packed_to_unpacked_bb, self.symbol_mapper, self.symbols_to_chips, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#self.connect(self, self.symbols_to_chips, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#self.connect(self, self.packed_to_unpacked_ss, self.chunks2symbols, self.rrc_filter, self)
#case when we use a stream of bits
#self.connect(self, self.chunks2symbols_b, self.rrc_filter, self)
if self.verbose:
self._print_verbage()
def __init__(self,
samples_per_symbol=_def_samples_per_symbol,
excess_bw=_def_excess_bw,
gray_code=_def_gray_code,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered differential BPSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param samples_per_symbol: samples per baud >= 2
@type samples_per_symbol: integer
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: 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 log: Log modulation data to files?
@type log: bool
"""
gr.hier_block2.__init__(self, "dbpsk_mod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._gray_code = gray_code
if self._samples_per_symbol < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol)
arity = pow(2,self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
else:
self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
self.diffenc = gr.diff_encoder_bb(arity)
self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
# pulse shaping filter
nfilts = 32
ntaps = nfilts * 11 * int(self._samples_per_symbol) # make nfilts filters of ntaps each
self.rrc_taps = gr.firdes.root_raised_cosine(
nfilts, # gain
nfilts, # sampling rate based on 32 filters in resampler
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.pfb_arb_resampler_ccf(self._samples_per_symbol, self.rrc_taps)
# Connect
self.connect(self, self.bytes2chunks, self.symbol_mapper, self.diffenc,
self.chunks2symbols, self.rrc_filter, self)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B")
parser.add_option(
"-f",
"--freq",
type="eng_float",
default=107.2e6,
help="set Tx frequency to FREQ [required]",
metavar="FREQ",
)
parser.add_option("--wavfile", type="string", default=None, help="open .wav audio file FILE")
parser.add_option("--xml", type="string", default="rds_data.xml", help="open .xml RDS data FILE")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
usrp_interp = 500
self.u = usrp.sink_c(0, usrp_interp)
print "USRP Serial: ", self.u.serial_number()
usrp_rate = self.u.dac_rate() / usrp_interp # 256 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using d'board", self.subdev.side_and_name()
# set max Tx gain, tune frequency and enable transmitter
gain = self.subdev.gain_range()[1]
self.subdev.set_gain(gain)
print "Gain set to", gain
if self.u.tune(self.subdev.which(), self.subdev, options.freq):
print "Tuned to", options.freq / 1e6, "MHz"
else:
sys.exit(1)
self.subdev.set_enable(True)
# open wav file containing floats in the [-1, 1] range, repeat
if options.wavfile is None:
print "Please provide a wavfile to transmit! Exiting\n"
sys.exit(1)
self.src = gr.wavfile_source(options.wavfile, True)
nchans = self.src.channels()
sample_rate = self.src.sample_rate()
bits_per_sample = self.src.bits_per_sample()
print nchans, "channels,", sample_rate, "samples/sec,", bits_per_sample, "bits/sample"
# resample to usrp rate
self.resample_left = blks2.rational_resampler_fff(usrp_rate, sample_rate)
self.resample_right = blks2.rational_resampler_fff(usrp_rate, sample_rate)
self.connect((self.src, 0), self.resample_left)
self.connect((self.src, 1), self.resample_right)
# create L+R (mono) and L-R (stereo)
self.audio_lpr = gr.add_ff()
self.audio_lmr = gr.sub_ff()
self.connect(self.resample_left, (self.audio_lpr, 0))
self.connect(self.resample_left, (self.audio_lmr, 0))
self.connect(self.resample_right, (self.audio_lpr, 1))
self.connect(self.resample_right, (self.audio_lmr, 1))
# low-pass filter for L+R
audio_lpr_taps = gr.firdes.low_pass(
0.5, # gain
usrp_rate, # sampling rate
15e3, # passband cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.audio_lpr_filter = gr.fir_filter_fff(1, audio_lpr_taps)
self.connect(self.audio_lpr, self.audio_lpr_filter)
# create pilot tone at 19 kHz
self.pilot = gr.sig_source_f(
usrp_rate, gr.GR_SIN_WAVE, 19e3, 5e-2 # sampling rate # waveform # frequency
) # amplitude
# upconvert L-R to 38 kHz and band-pass
self.mix_stereo = gr.multiply_ff()
audio_lmr_taps = gr.firdes.band_pass(
80, # gain
usrp_rate, # sampling rate
38e3 - 15e3, # low cutoff
38e3 + 15e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.audio_lmr_filter = gr.fir_filter_fff(1, audio_lmr_taps)
self.connect(self.audio_lmr, (self.mix_stereo, 0))
self.connect(self.pilot, (self.mix_stereo, 1))
self.connect(self.pilot, (self.mix_stereo, 2))
self.connect(self.mix_stereo, self.audio_lmr_filter)
# create RDS bitstream
# diff-encode, manchester-emcode, NRZ
# enforce the 1187.5bps rate
# pulse shaping filter (matched with receiver)
# mix with 57kHz carrier (equivalent to BPSK)
self.rds_enc = rds.data_encoder("rds_data.xml")
self.diff_enc = gr.diff_encoder_bb(2)
self.manchester1 = gr.map_bb([1, 2])
self.manchester2 = gr.unpack_k_bits_bb(2)
self.nrz = gr.map_bb([-1, 1])
self.c2f = gr.char_to_float()
self.rate_enforcer = rds.rate_enforcer(usrp_rate)
pulse_shaping_taps = gr.firdes.low_pass(
1, # gain
usrp_rate, # sampling rate
1.5e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.pulse_shaping = gr.fir_filter_fff(1, pulse_shaping_taps)
self.bpsk_mod = gr.multiply_ff()
self.connect(self.rds_enc, self.diff_enc, self.manchester1, self.manchester2, self.nrz, self.c2f)
self.connect(self.c2f, (self.rate_enforcer, 0))
self.connect(self.pilot, (self.rate_enforcer, 1))
self.connect(self.rate_enforcer, (self.bpsk_mod, 0))
self.connect(self.pilot, (self.bpsk_mod, 1))
self.connect(self.pilot, (self.bpsk_mod, 2))
self.connect(self.pilot, (self.bpsk_mod, 3))
# RDS band-pass filter
rds_filter_taps = gr.firdes.band_pass(
50, # gain
usrp_rate, # sampling rate
57e3 - 3e3, # low cutoff
57e3 + 3e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING,
)
self.rds_filter = gr.fir_filter_fff(1, rds_filter_taps)
self.connect(self.bpsk_mod, self.rds_filter)
# mix L+R, pilot, L-R and RDS
self.mixer = gr.add_ff()
self.connect(self.audio_lpr_filter, (self.mixer, 0))
self.connect(self.pilot, (self.mixer, 1))
self.connect(self.audio_lmr_filter, (self.mixer, 2))
self.connect(self.rds_filter, (self.mixer, 3))
# fm modulation, gain & TX
max_dev = 75e3
k = 2 * math.pi * max_dev / usrp_rate # modulator sensitivity
self.modulator = gr.frequency_modulator_fc(k)
self.gain = gr.multiply_const_cc(5e3)
self.connect(self.mixer, self.modulator, self.gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
self.fft = fftsink2.fft_sink_f(
panel, title="Pre FM modulation", fft_size=512 * 4, sample_rate=usrp_rate, y_per_div=20, ref_level=-20
)
self.connect(self.mixer, self.fft)
vbox.Add(self.fft.win, 1, wx.EXPAND)
if 0:
self.scope = scopesink2.scope_sink_f(panel, title="RDS encoder output", sample_rate=usrp_rate)
self.connect(self.rds_enc, self.scope)
vbox.Add(self.scope.win, 1, wx.EXPAND)
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Rds Tx")
_icon_path = "/home/azimout/.local/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.usrp_interp = usrp_interp = 500
self.dac_rate = dac_rate = 128e6
self.wav_rate = wav_rate = 44100
self.usrp_rate = usrp_rate = int(dac_rate / usrp_interp)
self.fm_max_dev = fm_max_dev = 120e3
##################################################
# Blocks
##################################################
self.band_pass_filter_0 = gr.interp_fir_filter_fff(
1,
firdes.band_pass(1, usrp_rate, 54e3, 60e3, 3e3, firdes.WIN_HAMMING,
6.76))
self.band_pass_filter_1 = gr.interp_fir_filter_fff(
1,
firdes.band_pass(1, usrp_rate, 23e3, 53e3, 2e3, firdes.WIN_HAMMING,
6.76))
self.blks2_rational_resampler_xxx_1 = blks2.rational_resampler_fff(
interpolation=usrp_rate,
decimation=wav_rate,
taps=None,
fractional_bw=None,
)
self.blks2_rational_resampler_xxx_1_0 = blks2.rational_resampler_fff(
interpolation=usrp_rate,
decimation=wav_rate,
taps=None,
fractional_bw=None,
)
self.gr_add_xx_0 = gr.add_vff(1)
self.gr_add_xx_1 = gr.add_vff(1)
self.gr_char_to_float_0 = gr.char_to_float()
self.gr_diff_encoder_bb_0 = gr.diff_encoder_bb(2)
self.gr_frequency_modulator_fc_0 = gr.frequency_modulator_fc(
2 * math.pi * fm_max_dev / usrp_rate)
self.gr_map_bb_0 = gr.map_bb(([-1, 1]))
self.gr_map_bb_1 = gr.map_bb(([1, 2]))
self.gr_multiply_xx_0 = gr.multiply_vff(1)
self.gr_multiply_xx_1 = gr.multiply_vff(1)
self.gr_rds_data_encoder_0 = rds.data_encoder(
"/media/dimitris/mywork/gr/dimitris/rds/trunk/src/test/rds_data.xml"
)
self.gr_rds_rate_enforcer_0 = rds.rate_enforcer(256000)
self.gr_sig_source_x_0 = gr.sig_source_f(usrp_rate, gr.GR_COS_WAVE,
19e3, 0.3, 0)
self.gr_sub_xx_0 = gr.sub_ff(1)
self.gr_unpack_k_bits_bb_0 = gr.unpack_k_bits_bb(2)
self.gr_wavfile_source_0 = gr.wavfile_source(
"/media/dimitris/mywork/gr/dimitris/rds/trunk/src/python/limmenso_stereo.wav",
True)
self.low_pass_filter_0 = gr.interp_fir_filter_fff(
1,
firdes.low_pass(1, usrp_rate, 1.5e3, 2e3, firdes.WIN_HAMMING,
6.76))
self.low_pass_filter_0_0 = gr.interp_fir_filter_fff(
1,
firdes.low_pass(1, usrp_rate, 15e3, 2e3, firdes.WIN_HAMMING, 6.76))
self.usrp_simple_sink_x_0 = grc_usrp.simple_sink_c(which=0, side="A")
self.usrp_simple_sink_x_0.set_interp_rate(500)
self.usrp_simple_sink_x_0.set_frequency(107.2e6, verbose=True)
self.usrp_simple_sink_x_0.set_gain(0)
self.usrp_simple_sink_x_0.set_enable(True)
self.usrp_simple_sink_x_0.set_auto_tr(True)
self.wxgui_fftsink2_0 = fftsink2.fft_sink_f(
self.GetWin(),
baseband_freq=0,
y_per_div=20,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=usrp_rate,
fft_size=1024,
fft_rate=30,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
##################################################
# Connections
##################################################
self.connect((self.gr_sig_source_x_0, 0),
(self.gr_rds_rate_enforcer_0, 1))
self.connect((self.gr_char_to_float_0, 0),
(self.gr_rds_rate_enforcer_0, 0))
self.connect((self.gr_map_bb_0, 0), (self.gr_char_to_float_0, 0))
self.connect((self.gr_frequency_modulator_fc_0, 0),
(self.usrp_simple_sink_x_0, 0))
self.connect((self.gr_add_xx_1, 0),
(self.gr_frequency_modulator_fc_0, 0))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_add_xx_1, 1))
self.connect((self.gr_sub_xx_0, 0), (self.gr_multiply_xx_1, 2))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_1, 1))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_1, 0))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 3))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 2))
self.connect((self.blks2_rational_resampler_xxx_1_0, 0),
(self.gr_add_xx_0, 1))
self.connect((self.blks2_rational_resampler_xxx_1, 0),
(self.gr_add_xx_0, 0))
self.connect((self.blks2_rational_resampler_xxx_1_0, 0),
(self.gr_sub_xx_0, 1))
self.connect((self.blks2_rational_resampler_xxx_1, 0),
(self.gr_sub_xx_0, 0))
self.connect((self.gr_wavfile_source_0, 1),
(self.blks2_rational_resampler_xxx_1_0, 0))
self.connect((self.gr_wavfile_source_0, 0),
(self.blks2_rational_resampler_xxx_1, 0))
self.connect((self.gr_rds_data_encoder_0, 0),
(self.gr_diff_encoder_bb_0, 0))
self.connect((self.gr_diff_encoder_bb_0, 0), (self.gr_map_bb_1, 0))
self.connect((self.gr_map_bb_1, 0), (self.gr_unpack_k_bits_bb_0, 0))
self.connect((self.gr_unpack_k_bits_bb_0, 0), (self.gr_map_bb_0, 0))
self.connect((self.gr_rds_rate_enforcer_0, 0),
(self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.gr_multiply_xx_0, 0))
self.connect((self.gr_multiply_xx_0, 0), (self.band_pass_filter_0, 0))
self.connect((self.band_pass_filter_0, 0), (self.gr_add_xx_1, 0))
self.connect((self.gr_multiply_xx_1, 0), (self.band_pass_filter_1, 0))
self.connect((self.band_pass_filter_1, 0), (self.gr_add_xx_1, 3))
self.connect((self.gr_add_xx_1, 0), (self.wxgui_fftsink2_0, 0))
self.connect((self.gr_sig_source_x_0, 0), (self.gr_multiply_xx_0, 1))
self.connect((self.gr_add_xx_0, 0), (self.low_pass_filter_0_0, 0))
self.connect((self.low_pass_filter_0_0, 0), (self.gr_add_xx_1, 2))
def __init__(self, fg,
samples_per_symbol=_def_samples_per_symbol,
excess_bw=_def_excess_bw,
gray_code=_def_gray_code,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered differential BPSK modulation.
The input is a byte stream (unsigned char) and the
output is the complex modulated signal at baseband.
@param fg: flow graph
@type fg: flow graph
@param samples_per_symbol: samples per baud >= 2
@type samples_per_symbol: integer
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: 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 log: Log modulation data to files?
@type log: bool
"""
self._fg = fg
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._gray_code = gray_code
if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2:
raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol)
ntaps = 11 * self._samples_per_symbol
arity = pow(2,self.bits_per_symbol())
# turn bytes into k-bit vectors
self.bytes2chunks = \
gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST)
if self._gray_code:
self.symbol_mapper = gr.map_bb(psk.binary_to_gray[arity])
else:
self.symbol_mapper = gr.map_bb(psk.binary_to_ungray[arity])
self.diffenc = gr.diff_encoder_bb(arity)
self.chunks2symbols = gr.chunks_to_symbols_bc(psk.constellation[arity])
# pulse shaping filter
self.rrc_taps = gr.firdes.root_raised_cosine(
self._samples_per_symbol, # gain (samples_per_symbol since we're
# interpolating by samples_per_symbol)
self._samples_per_symbol, # sampling rate
1.0, # symbol rate
self._excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol,
self.rrc_taps)
# Connect
fg.connect(self.bytes2chunks, self.symbol_mapper, self.diffenc,
self.chunks2symbols, self.rrc_filter)
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Initialize base class
gr.hier_block.__init__(self, self._fg, self.bytes2chunks, self.rrc_filter)
def __init__(self, frame, panel, vbox, argv):
stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)
parser = OptionParser(option_class=eng_option)
parser.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
parser.add_option("-f",
"--freq",
type="eng_float",
default=107.2e6,
help="set Tx frequency to FREQ [required]",
metavar="FREQ")
parser.add_option("--wavfile",
type="string",
default=None,
help="open .wav audio file FILE")
parser.add_option("--xml",
type="string",
default="rds_data.xml",
help="open .xml RDS data FILE")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
sys.exit(1)
usrp_interp = 500
self.u = usrp.sink_c(0, usrp_interp)
print "USRP Serial: ", self.u.serial_number()
usrp_rate = self.u.dac_rate() / usrp_interp # 256 kS/s
# determine the daughterboard subdevice we're using
if options.tx_subdev_spec is None:
options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u)
self.u.set_mux(
usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec))
self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec)
print "Using d'board", self.subdev.side_and_name()
# set max Tx gain, tune frequency and enable transmitter
gain = self.subdev.gain_range()[1]
self.subdev.set_gain(gain)
print "Gain set to", gain
if self.u.tune(self.subdev.which(), self.subdev, options.freq):
print "Tuned to", options.freq / 1e6, "MHz"
else:
sys.exit(1)
self.subdev.set_enable(True)
# open wav file containing floats in the [-1, 1] range, repeat
if options.wavfile is None:
print "Please provide a wavfile to transmit! Exiting\n"
sys.exit(1)
self.src = gr.wavfile_source(options.wavfile, True)
nchans = self.src.channels()
sample_rate = self.src.sample_rate()
bits_per_sample = self.src.bits_per_sample()
print nchans, "channels,", sample_rate, "samples/sec,", \
bits_per_sample, "bits/sample"
# resample to usrp rate
self.resample_left = blks2.rational_resampler_fff(
usrp_rate, sample_rate)
self.resample_right = blks2.rational_resampler_fff(
usrp_rate, sample_rate)
self.connect((self.src, 0), self.resample_left)
self.connect((self.src, 1), self.resample_right)
# create L+R (mono) and L-R (stereo)
self.audio_lpr = gr.add_ff()
self.audio_lmr = gr.sub_ff()
self.connect(self.resample_left, (self.audio_lpr, 0))
self.connect(self.resample_left, (self.audio_lmr, 0))
self.connect(self.resample_right, (self.audio_lpr, 1))
self.connect(self.resample_right, (self.audio_lmr, 1))
# low-pass filter for L+R
audio_lpr_taps = gr.firdes.low_pass(
0.5, # gain
usrp_rate, # sampling rate
15e3, # passband cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.audio_lpr_filter = gr.fir_filter_fff(1, audio_lpr_taps)
self.connect(self.audio_lpr, self.audio_lpr_filter)
# create pilot tone at 19 kHz
self.pilot = gr.sig_source_f(
usrp_rate, # sampling rate
gr.GR_SIN_WAVE, # waveform
19e3, # frequency
5e-2) # amplitude
# upconvert L-R to 38 kHz and band-pass
self.mix_stereo = gr.multiply_ff()
audio_lmr_taps = gr.firdes.band_pass(
80, # gain
usrp_rate, # sampling rate
38e3 - 15e3, # low cutoff
38e3 + 15e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.audio_lmr_filter = gr.fir_filter_fff(1, audio_lmr_taps)
self.connect(self.audio_lmr, (self.mix_stereo, 0))
self.connect(self.pilot, (self.mix_stereo, 1))
self.connect(self.pilot, (self.mix_stereo, 2))
self.connect(self.mix_stereo, self.audio_lmr_filter)
# create RDS bitstream
# diff-encode, manchester-emcode, NRZ
# enforce the 1187.5bps rate
# pulse shaping filter (matched with receiver)
# mix with 57kHz carrier (equivalent to BPSK)
self.rds_enc = rds.data_encoder('rds_data.xml')
self.diff_enc = gr.diff_encoder_bb(2)
self.manchester1 = gr.map_bb([1, 2])
self.manchester2 = gr.unpack_k_bits_bb(2)
self.nrz = gr.map_bb([-1, 1])
self.c2f = gr.char_to_float()
self.rate_enforcer = rds.rate_enforcer(usrp_rate)
pulse_shaping_taps = gr.firdes.low_pass(
1, # gain
usrp_rate, # sampling rate
1.5e3, # passband cutoff
2e3, # transition width
gr.firdes.WIN_HAMMING)
self.pulse_shaping = gr.fir_filter_fff(1, pulse_shaping_taps)
self.bpsk_mod = gr.multiply_ff()
self.connect (self.rds_enc, self.diff_enc, self.manchester1, \
self.manchester2, self.nrz, self.c2f)
self.connect(self.c2f, (self.rate_enforcer, 0))
self.connect(self.pilot, (self.rate_enforcer, 1))
self.connect(self.rate_enforcer, (self.bpsk_mod, 0))
self.connect(self.pilot, (self.bpsk_mod, 1))
self.connect(self.pilot, (self.bpsk_mod, 2))
self.connect(self.pilot, (self.bpsk_mod, 3))
# RDS band-pass filter
rds_filter_taps = gr.firdes.band_pass(
50, # gain
usrp_rate, # sampling rate
57e3 - 3e3, # low cutoff
57e3 + 3e3, # high cutoff
1e3, # transition width
gr.firdes.WIN_HAMMING)
self.rds_filter = gr.fir_filter_fff(1, rds_filter_taps)
self.connect(self.bpsk_mod, self.rds_filter)
# mix L+R, pilot, L-R and RDS
self.mixer = gr.add_ff()
self.connect(self.audio_lpr_filter, (self.mixer, 0))
self.connect(self.pilot, (self.mixer, 1))
self.connect(self.audio_lmr_filter, (self.mixer, 2))
self.connect(self.rds_filter, (self.mixer, 3))
# fm modulation, gain & TX
max_dev = 75e3
k = 2 * math.pi * max_dev / usrp_rate # modulator sensitivity
self.modulator = gr.frequency_modulator_fc(k)
self.gain = gr.multiply_const_cc(5e3)
self.connect(self.mixer, self.modulator, self.gain, self.u)
# plot an FFT to verify we are sending what we want
if 1:
self.fft = fftsink2.fft_sink_f(panel,
title="Pre FM modulation",
fft_size=512 * 4,
sample_rate=usrp_rate,
y_per_div=20,
ref_level=-20)
self.connect(self.mixer, self.fft)
vbox.Add(self.fft.win, 1, wx.EXPAND)
if 0:
self.scope = scopesink2.scope_sink_f(panel,
title="RDS encoder output",
sample_rate=usrp_rate)
self.connect(self.rds_enc, self.scope)
vbox.Add(self.scope.win, 1, wx.EXPAND)