Forum: GNU Radio Cannot receive after one run of the code?

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Zenny Z. (Guest)
on 2008-10-21 03:25
(Received via mailing list)
Dear All,

I am writing because I am really in need for some advice. I wrote a
program that

(1) receives from the sender and estimates the channel
(2) switch to the transmitting mode and sends the channel estimation
back to the sender
(3) switch back to the receiving mode to receive data

A while ago, I asked about how to switch between these modes without
having to stop the flow graph, and Eric gave me excellent advice on
looking at tunnel.py. Recently, after did some optimizations, I found
that the code is having a weird problem, and I have struggled on it
about a week on it but still don't know what to do.

Basically, after power-on the USRP, the code runs perfectly once. But
most often, it runs well exactly once -- the next time I run it, the
receiver at step 1 cannot receive any signal. To run it again, I have
to unplug the USRP.

Here, by not receiving any signal, I mean that the signals read from
USRP have an average square value of around 0.8. When things are
working fine, the value is around 200 when the sender is not sending,
and is around 1000000 when the sender is sending.

At first I thought it was because I did not set mux right. But it does
not seem to be so. I also noticed that after I screw it up, I cannot
even run the benchmark_rx.py, because it will also not receive
anything. But I can run usrp_oscope.py and I can see the waveform when
I have a transmitter sending.

I really appreciate if someone could give me a hint on this. Thanks so
much!


Best regards,
Zhenghao

---------------------------------------------------------------

I have simplified my code and I am posting it here. This code has
exactly the same problem as I described. If other information is
needed, please let me know. Thanks!

from gnuradio import gr, gru, modulation_utils
from gnuradio.blksimpl import psk
import cmath
import Numeric
from pprint import pprint
from gnuradio import usrp
from pick_bitrate import pick_rx_bitrate
import time
import sys
from array    import array
from pick_bitrate import pick_tx_bitrate

# default values (used in __init__ and add_options)
_def_samples_per_symbol = 2
_def_excess_bw = 0.35
_def_gray_code = True
_def_verbose = True
_def_log = True

_def_costas_alpha = 0.05 # the original setting

_def_gain_mu = 0.03
_def_mu = 0.05
_def_omega_relative_limit = 0.005

_def_rv_tx_freq = 2470000000
_def_rv_rx_freq = 2420000000

_def_found_delta_f = 0.025

_def_bitrate = 500000

_def_PI = 3.141592653
_def_rv_tx_power = 2000 #org: 12000

#
/////////////////////////////////////////////////////////////////////////////
#                             DBPSK demodulator
#
#      Differentially coherent detection of differentially encoded BPSK
#
/////////////////////////////////////////////////////////////////////////////

class dbpsk_demod(gr.hier_block):

    def __init__(self, fg,
                 samples_per_symbol=_def_samples_per_symbol,
                 excess_bw=_def_excess_bw,
                 costas_alpha=_def_costas_alpha,
                 gain_mu=_def_gain_mu,
                 mu=_def_mu,
                 omega_relative_limit=_def_omega_relative_limit,
                 gray_code=_def_gray_code,
                 verbose=_def_verbose,
                 log=_def_log):
        """
  Hierarchical block for RRC-filtered differential BPSK demodulation

  The input is the complex modulated signal at baseband.
  The output is a stream of bits packed 1 bit per byte (LSB)

  @param fg: flow graph
  @type fg: flow graph
  @param samples_per_symbol: samples per symbol >= 2
  @type samples_per_symbol: float
  @param excess_bw: Root-raised cosine filter excess bandwidth
  @type excess_bw: float
        @param costas_alpha: loop filter gain
        @type costas_alphas: float
        @param gain_mu: for M&M block
        @type gain_mu: float
        @param mu: for M&M block
        @type mu: float
        @param omega_relative_limit: for M&M block
        @type omega_relative_limit: 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._samples_per_symbol = samples_per_symbol
        self._excess_bw = excess_bw
        self._costas_alpha = costas_alpha
        self._gain_mu = gain_mu
        self._mu = mu
        self._omega_relative_limit = omega_relative_limit
        self._gray_code = gray_code

        self._rx_freq            = _def_rv_rx_freq
        self._rx_gain            = 45           # receiver's gain
        self._rx_subdev_spec     = None
        self._bitrate            = _def_bitrate
        self._decim              = 64           # Decimating rate for
the USRP (prelim)
        self._fusb_block_size    = 0
        self._fusb_nblocks       = 0


        if self._rx_freq is None:
            sys.stderr.write("-f FREQ or --freq FREQ or --rx-freq FREQ
must be specified\n")
            raise SystemExit

        # Set up USRP source; also adjusts decim, samples_per_symbol,
and bitrate
        self._setup_usrp_source()

        g = self.subdev.gain_range()
        if 1:
            print "Rx Gain Range: minimum = %g, maximum = %g, step size
= %g" \
                  % (g[0], g[1], g[2])

        self.set_gain(self._rx_gain)

        self.set_auto_tr(True)                 # enable Auto
Transmit/Receive switching

        # Set RF frequency
        ok = self.set_freq(self._rx_freq)
        if not ok:
            print "Failed to set Rx frequency to %s" %
(eng_notation.num_to_str(self._rx_freq))
            raise ValueError, eng_notation.num_to_str(self._rx_freq)

        alpha = 0.001
        thresh = 30   # in dB, will have to adjust

        self.probe = gr.probe_avg_mag_sqrd_c(thresh,alpha)

        # Design filter to get actual channel we want
        sw_decim = 1
        chan_coeffs = gr.firdes.low_pass (1.0,                  # gain
                                          sw_decim *
self._samples_per_symbol, # sampling rate
                                          1.0,                  #
midpoint of trans. band
                                          0.5,                  #
width of trans. band
                                          gr.firdes.WIN_HANN)   # filter
type

        # Decimating channel filter
        # complex in and out, float taps
        self.chan_filt = gr.fft_filter_ccc(sw_decim, chan_coeffs)
        #self.chan_filt = gr.fir_filter_ccf(sw_decim, chan_coeffs)


        if samples_per_symbol < 2:
            raise TypeError, "samples_per_symbol must be >= 2, is %r"
% (samples_per_symbol,)

        arity = pow(2,self.bits_per_symbol())

        # Automatic gain control
        scale = (1.0/16384.0)
        self.pre_scaler = gr.multiply_const_cc(scale)   # scale the
signal from full-range to +-1
        #self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
        self.agc = gr.feedforward_agc_cc(16, 1.0)


        ntaps = 11 * self._samples_per_symbol
        self.rrc_taps = gr.firdes.root_raised_cosine(
            1.0,                      # gain
            self._samples_per_symbol, # sampling rate
            1.0,                      # symbol rate
            self._excess_bw,          # excess bandwidth (roll-off
factor)
            ntaps)

        self.rrc_filter=gr.fir_filter_ccf(1, self.rrc_taps)


        # find closest constellation point
        rot = 1
  #rot = .707 + .707j
  #print "psk.constellation[arity]=", psk.constellation[arity]  #chen
        rotated_const = map(lambda pt: pt * rot,
psk.constellation[arity])
        print "rotated_const =", rotated_const


       # symbol clock recovery
  omega = self._samples_per_symbol
        gain_omega = .25 * self._gain_mu * self._gain_mu
  #if not self._mm_gain_mu:
        #    self._mm_gain_mu = 0.1

        #self._mm_omega = self._samples_per_symbol
        #self._mm_gain_omega = .25 * self._mm_gain_mu * self._mm_gain_mu
        self._costas_beta  = 0.25 * self._costas_alpha *
self._costas_alpha
        #fmin = -0.025
        #fmax = 0.025
        fmin = -0.1
        fmax = 0.1

        self.receiver=gr.mpsk_receiver_cc(arity, 0,
                                         self._costas_alpha,
self._costas_beta,
                                         fmin, fmax,
                                         self._mu, self._gain_mu,
                                         omega, gain_omega,
                                         self._omega_relative_limit)


        self.diffdec = gr.diff_phasor_cc()
        #self.diffdec = gr.diff_decoder_bb(arity)

        self.slicer = gr.constellation_decoder_cb(rotated_const,
range(arity))

        if self._gray_code:
            self.symbol_mapper = gr.map_bb(psk.gray_to_binary[2])
        else:
            self.symbol_mapper = gr.map_bb(psk.ungray_to_binary[2])

        # unpack the k bit vector into a stream of bits
        self.unpack = gr.unpacked_to_packed_bb(self.bits_per_symbol(),
gr.GR_MSB_FIRST)

        self.file_sink_1 = gr.file_sink(gr.sizeof_gr_complex,
"DBPSKDemod.dat")

        # Connect and Initialize base class

  #self._fg.connect(self.u, self.pre_scaler, self.agc, self.chan_filt,
self.rrc_filter, self.receiver, self.file_sink_1)
  self._fg.connect(self.u, self.pre_scaler, self.chan_filt,
self.rrc_filter, self.receiver, self.file_sink_1)

  self.dst = gr.vector_sink_b()

        self._fg.connect(self.u, self.probe)

        gr.hier_block.__init__(self, self._fg, self.u, self.file_sink_1)

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def bits_per_symbol(self=None):   # staticmethod that's also
callable on an instance
        return 1
    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a
static method.  RTFM


    def _setup_usrp_source(self):
        self.u = usrp.source_c (fusb_block_size=self._fusb_block_size,
                                fusb_nblocks=self._fusb_nblocks)
        adc_rate = self.u.adc_rate()

        # derive values of bitrate, samples_per_symbol, and decim from
desired info
        (self._bitrate, self._samples_per_symbol, self._decim) = \
            pick_rx_bitrate(self._bitrate, 1, \
                            self._samples_per_symbol, self._decim,
adc_rate)

        self.u.set_decim_rate(self._decim)

        # determine the daughterboard subdevice we're using
        if self._rx_subdev_spec is None:
            self._rx_subdev_spec = usrp.pick_rx_subdevice(self.u)
        self.subdev = usrp.selected_subdev(self.u, self._rx_subdev_spec)

  mux_value = usrp.determine_rx_mux_value(self.u, self._rx_subdev_spec)
  self.u.set_mux(mux_value)
        #print "-------------- usrp source mux_value = %d
----------------" %mux_value

    def set_freq(self, target_freq):
        """
        Set the center frequency we're interested in.

        @param target_freq: frequency in Hz
        @rypte: bool

        Tuning is a two step process.  First we ask the front-end to
        tune as close to the desired frequency as it can.  Then we use
        the result of that operation and our target_frequency to
        determine the value for the digital up converter.
        """
        r = self.u.tune(0, self.subdev, target_freq)
        if r:
            return True

        return False

    def set_gain(self, gain):
        """
        Sets the analog gain in the USRP
        """
        if gain is None:
            r = self.subdev.gain_range()
            gain = (r[0] + r[1])/2               # set gain to midpoint
        self.gain = gain
        return self.subdev.set_gain(gain)

    def set_auto_tr(self, enable):
        return self.subdev.set_auto_tr(enable)

    def bitrate(self):
        return self._bitrate

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def decim(self):
        return self._decim

    def carrier_sensed(self):
        """
        Return True if we think carrier is present.
        """
        #return self.probe.level() > X
        return self.probe.unmuted()

    def carrier_threshold(self):
        """
        Return current setting in dB.
        """
        return self.probe.threshold()

    def set_carrier_threshold(self, threshold_in_db):
        """
        Set carrier threshold.

        @param threshold_in_db: set detection threshold
        @type threshold_in_db:  float (dB)
        """
        self.probe.set_threshold(threshold_in_db)



#//////////////////////////////////////////////////////////////////
#
#
#//////////////////////////////////////////////////////////////////

class dbpsk_mod(gr.hier_block):

    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._tx_freq            = _def_rv_tx_freq
        self._tx_amplitude   = _def_rv_tx_power #original setting is
12000
  self._fusb_block_size    = 0
        self._fusb_nblocks   = 0
        self._bitrate            = _def_bitrate
  self._tx_subdev_spec     = None
        self._fg = fg
        self._samples_per_symbol = samples_per_symbol
        self._excess_bw = excess_bw
        self._gray_code = gray_code
  self.phase_diff_est = 192

        # Set up USRP sink; also adjusts interp, samples_per_symbol, and
bitrate
        self._setup_usrp_sink()

        # Set center frequency of USRP
        ok = self.set_freq(self._tx_freq)
        if not ok:
            print "Failed to set Tx frequency to %s" %
(eng_notation.num_to_str(self._tx_freq),)
            raise ValueError

        # Set the USRP for maximum transmit gain
        # (Note that on the RFX cards this is a nop.)
        self.set_gain(self.subdev.gain_range()[1])

        self.amp = gr.multiply_const_cc(1)
        self.set_tx_amplitude(self._tx_amplitude)

        # enable Auto Transmit/Receive switching
        self.set_auto_tr(True)



        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.chunks2symbols =
gr.chunks_to_symbols_bc(psk.constellation[2])

        self.rrc_taps = gr.firdes.root_raised_cosine(
            1.0,                      # gain
            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)

  self.bytes_src1 = gr.null_source(gr.sizeof_char)

  self.diffenc = gr.diff_encoder_bb(arity)

        fg.connect(self.bytes_src1, self.bytes2chunks,
self.symbol_mapper, self.diffenc, self.chunks2symbols,
self.rrc_filter, self.amp, self.u)

  gr.hier_block.__init__(self, self._fg, self.bytes_src1, self.u)

    def samples_per_symbol(self):
        return self._samples_per_symbol

    def bits_per_symbol(self=None):   # static method that's also
callable on an instance
        return 1
    bits_per_symbol = staticmethod(bits_per_symbol)      # make it a
static method.  RTFM


    def _setup_usrp_sink(self):
        """
        Creates a USRP sink, determines the settings for best bitrate,
        and attaches to the transmitter's subdevice.
        """

  self.u = usrp.sink_c(fusb_block_size=self._fusb_block_size,
                             fusb_nblocks=self._fusb_nblocks)
        dac_rate = self.u.dac_rate();

        # derive values of bitrate, samples_per_symbol, and interp
from desired info
        (self._bitrate, self._samples_per_symbol, self._interp) = \
            pick_tx_bitrate(self._bitrate, 1,
                            self._samples_per_symbol, None, dac_rate)

        self.u.set_interp_rate(self._interp)

        # determine the daughterboard subdevice we're using
        if self._tx_subdev_spec is None:
            self._tx_subdev_spec = usrp.pick_tx_subdevice(self.u)

  mux_value = usrp.determine_tx_mux_value(self.u, self._tx_subdev_spec)
        self.u.set_mux(mux_value)


        self.subdev = usrp.selected_subdev(self.u, self._tx_subdev_spec)


    def set_freq(self, target_freq):
        """
        Set the center frequency we're interested in.

        @param target_freq: frequency in Hz
        @rypte: bool

        Tuning is a two step process.  First we ask the front-end to
        tune as close to the desired frequency as it can.  Then we use
        the result of that operation and our target_frequency to
        determine the value for the digital up converter.
        """
        r = self.u.tune(self.subdev._which, self.subdev, target_freq)
        if r:
            return True

        return False

    def set_gain(self, gain):
        """
        Sets the analog gain in the USRP
        """
        self.gain = gain
        self.subdev.set_gain(gain)

    def set_tx_amplitude(self, ampl):
        """
        Sets the transmit amplitude sent to the USRP
        @param: ampl 0 <= ampl < 32768.  Try 8000
        """
        self._tx_amplitude = max(0.0, min(ampl, 32767.0))
        self.amp.set_k(self._tx_amplitude)

    def set_auto_tr(self, enable):
        """
        Turns on auto transmit/receive of USRP daughterboard (if
exits; else ignored)
        """
        return self.subdev.set_auto_tr(enable)


if __name__ == '__main__':

    fg1 = gr.flow_graph()
    objDemod1 = dbpsk_demod(fg1)
    fg1.start() #objDemod1._fg.start()
    count = 0
    while count < 10:
        time.sleep(0.1) #orig: 0.001
        print "level %f" % objDemod1.probe.level()
        count = count + 1

    fg1.stop()#objDemod1._fg.stop()

    fg2 = gr.flow_graph()
    objmod = dbpsk_mod(fg2)
    objmod.set_tx_amplitude(_def_rv_tx_power)
    fg2.start()
    time.sleep(0.003)
    objmod.set_tx_amplitude(0)
    fg2.stop()
This topic is locked and can not be replied to.