[Discuss-gnuradio] sound card rate

[shijesh a.k]

--------------------------------------------------------------------------------
Hello friends,
 
I(shijesh) made debute to USRP & GNUradio a few days back.
I have a querry as mentioned after the environment observations given below
 
My environment is :
            O.S    ::    Ubuntu 7.04 Feisty fawn
            CPU    ::     Core2 DUO Intel
            gcc    ::     4.2.0
            SWIG   ::    1.3.31
  GNU CODE VERSION ::    3.0.4

I got the following error messages when i tried to run a program ( which i believe is to receive AM/FM/WFM)

**########################################################################**
ERROR ON EXECUTION OF THE PROGRAM
###############################################################################

address@hidden:/home/sabu# GNUradio/gnuradio-3.0.4/gnuradio-examples/python/usrp/usrp_rx_nogui.py -f 101.9M -m FM -o 44100

>>> gr_fir_ccc: using SSE
>>> gr_fir_fff: using SSE
audio_alsa_sink[hw:0,0]: set_period_time_near failed: Invalid argument
Traceback (most recent call last):
  File "GNUradio/gnuradio-3.0.4/gnuradio-examples/python/usrp/usrp_rx_nogui.py", line 186, in

<module>
    main()
  File "GNUradio/gnuradio-3.0.4/gnuradio-examples/python/usrp/usrp_rx_nogui.py", line 179, in main
    fg = app_flow_graph(options, args)
  File "GNUradio/gnuradio-3.0.4/gnuradio-examples/python/usrp/usrp_rx_nogui.py", line 153, in

__init__
    AUDIO = audio.sink(options.output_rate, "")
  File "/usr/local/lib/python2.5/site-packages/gnuradio/audio_alsa.py", line 228in sink
    return _audio_alsa.sink(*args)
RuntimeError: audio_alsa_sink

**############################################################################**
 PROGRAM FOR RECEPTION OF FM/AM/WFM
**#############################################################################**

#!/usr/bin/env python

from gnuradio import gr, gru, usrp, optfir, audio, eng_notation, blks
from gnuradio.eng_option import eng_option
from optparse import OptionParser

"""
This example application demonstrates receiving and demodulating
different types of signals using the USRP.

A receive chain is built up of the following signal processing
blocks:

USRP  - Daughter board source generating complex baseband signal.
CHAN  - Low pass filter to select channel bandwidth
RFSQL - RF squelch zeroing output when input power below threshold
AGC   - Automatic gain control leveling signal at [-1.0, +1.0]
DEMOD - Demodulation block appropriate to selected signal type.
        This converts the complex baseband to real audio frequencies,
 and applies an appropriate low pass decimating filter.
CTCSS - Optional tone squelch zeroing output when tone is not present.
RSAMP - Resampler block to convert audio sample rate to user specified
        sound card output rate.
AUDIO - Audio sink for playing final output to speakers.

The following are required command line parameters:

-f FREQ  USRP receive frequency
-m MOD  Modulation type, select from AM, FM, or WFM

The following are optional command line parameters:

-R SUBDEV       Daughter board specification, defaults to first found
-c FREQ         Calibration offset.  Gets added to receive frequency.
                Defaults to 0.0 Hz.
-g GAIN         Daughterboard gain setting. Defaults to mid-range.
-o RATE         Sound card output rate. Defaults to 32000. Useful if
                your sound card only accepts particular sample rates.
-r RFSQL RF squelch in db. Defaults to -50.0.
-p FREQ  CTCSS frequency.  Opens squelch when tone is present.

Once the program is running, ctrl-break (Ctrl-C) stops operation.

Please see fm_demod.py and am_demod.py for details of the demodulation
blocks.
"""

# (usrp_decim, channel_decim, audio_decim, channel_pass, channel_stop, demod)
demod_params = {
  'AM'  : (250, 16, 1,  5000,   8000, blks.demod_10k0a3e_cf),
  'FM'  : (250,  8, 4,  8000,   9000, blks.demod_20k0f3e_cf),
  'WFM' : (250,  1, 8, 90000, 100000, blks.demod_200kf3e_cf)
        }

class usrp_source_c(gr.hier_block):
    """
    Create a USRP source object supplying complex floats.
   
    Selects user supplied subdevice or chooses first available one.

    Calibration value is the offset from the tuned frequency to
    the actual frequency.      
    """
    def __init__(self, fg, subdev_spec, decim, gain=None, calibration=0.0):
 self._decim = decim
        self._src = usrp.source_c()
        if subdev_spec is None:
            subdev_spec = usrp.pick_rx_subdevice(self._src)
        self._subdev = usrp.selected_subdev(self._src, subdev_spec)
        self._src.set_mux(usrp.determine_rx_mux_value(self._src, subdev_spec))
        self._src.set_decim_rate(self._decim)

 # If no gain specified, set to midrange
 if gain is None:
     g = self._subdev.gain_range()
     gain = (g[0]+g[1])/2.0

        self._subdev.set_gain(gain)
        self._cal = calibration
 gr.hier_block.__init__(self, fg, self._src, self._src)

    def tune(self, freq):
     result = usrp.tune(self._src, 0, self._subdev, freq+self._cal)
     # TODO: deal with residual

    def rate(self):
 return self._src.adc_rate()/self._decim

class app_flow_graph(gr.flow_graph):
    def __init__(self, options, args):
 gr.flow_graph.__init__(self)
 self.options = options
 self.args = args

 (usrp_decim, channel_decim, audio_decim,
  channel_pass, channel_stop, demod) = demod_params[options.modulation]

        USRP = usrp_source_c(self,       # Flow graph
       options.rx_subdev_spec, # Daugherboard spec
                     usrp_decim,          # IF decimation ratio
       options.gain,      # Receiver gain
       options.calibration)    # Frequency offset
 USRP.tune(options.frequency)

 if_rate = USRP.rate()
        channel_rate = if_rate // channel_decim
 audio_rate = channel_rate // audio_decim

 CHAN_taps = optfir.low_pass(1.0,         # Filter gain
       if_rate,   # Sample rate
       channel_pass, # One sided modulation bandwidth
                            channel_stop, # One sided channel bandwidth
       0.1,   # Passband ripple
       60)    # Stopband attenuation

 CHAN = gr.freq_xlating_fir_filter_ccf(channel_decim, # Decimation rate
                                       CHAN_taps,     # Filter taps
           0.0,       # Offset frequency
           if_rate)      # Sample rate

 RFSQL = gr.pwr_squelch_cc(options.rf_squelch,    # Power threshold
                           125.0/channel_rate,   # Time constant
      channel_rate/20,       # 50ms rise/fall
      False)   # Zero, not gate output

 AGC = gr.agc_cc(1.0/channel_rate,  # Time constant
   1.0,         # Reference power
   1.0,               # Initial gain
   1.0)     # Maximum gain

 DEMOD = demod(self, channel_rate, audio_decim)

 # From RF to audio
        self.connect(USRP, CHAN, RFSQL, AGC, DEMOD)

 # Optionally add CTCSS and RSAMP if needed
 tail = DEMOD
 if options.ctcss != None and options.ctcss > 60.0:
     CTCSS = gr.ctcss_squelch_ff(audio_rate,    # Sample rate
            options.ctcss) # Squelch tone
     self.connect(DEMOD, CTCSS)
     tail = CTCSS

 if options.output_rate != audio_rate:
     out_lcm = gru.lcm(audio_rate, options.output_rate)
     out_interp = int(out_lcm // audio_rate)
     out_decim = int(out_lcm // options.output_rate)
     RSAMP = blks.rational_resampler_fff(self, out_interp, out_decim)
     self.connect(tail, RSAMP)
     tail = RSAMP

 # Send to default audio output
        AUDIO = audio.sink(options.output_rate, "")
 self.connect(tail, AUDIO)
 
def main():
    parser = OptionParser(option_class=eng_option)
    parser.add_option("-f", "--frequency", type="eng_float",
                      help="set receive frequency to Hz", metavar="Hz")
    parser.add_option("-R", "--rx-subdev-spec", type="subdev",
                      help="select USRP Rx side A or B", metavar="SUBDEV")
    parser.add_option("-c",   "--calibration", type="eng_float", default=0.0,
                      help="set frequency offset to Hz", metavar="Hz")
    parser.add_option("-g", "--gain", type="int", default=None,
                      help="set RF gain", metavar="dB")
    parser.add_option("-m", "--modulation", type="choice", choices=('AM','FM','WFM'),
                      help="set modulation type (AM,FM)", metavar="TYPE")
    parser.add_option("-o", "--output-rate", type="int", default=32000,
                      help="set audio output rate to RATE", metavar="RATE")
    parser.add_option("-r", "--rf-squelch", type="eng_float", default=-50.0,
                      help="set RF squelch to dB", metavar="dB")
    parser.add_option("-p", "--ctcss", type="float",
        help="set CTCSS squelch to FREQ", metavar="FREQ")
    (options, args) = parser.parse_args()

    if options.frequency < 1e6:
 options.frequency *= 1e6
 
    fg = app_flow_graph(options, args)
    try:
        fg.run()
    except KeyboardInterrupt:
        pass

if __name__ == "__main__":
    main()
 
**#################################################################################**
                PROGRAM ENDS
**#################################################################################**

what i had undestood is that it is because my PC's sound card sampling rate was 44100, and NOT 32000 as required by the program, I have also tried with the following modification to the command,but it didn't work.

########################################
address@hidden:/home/sabu# GNUradio/gnuradio-3.0.4/gnuradio-examples/python/usrp/usrp_rx_nogui.py -f 101.9M -m FM -o plughw:0,0
########################################

I know that it is obviously due to the fact that in the program it accepts only an integer value , while iam trying to enter a string, NOW WHAT EXACTLY I WHAT TO KNOW IS THAT HOW COULD I MODIFYING THE PROGRAM TO MAKE IT RUN WITHOUT ERROR ? HOW TO GET RID OF THE SAMPLING RATE PROBLEM

I know that it is a silly question for all of u friends, but for me it really will be a worth,  Please extend your helping hand...(I am in a ditch.!)

 

SHIJESH AK
INDIA

---

 Try the revolutionary next-gen Yahoo! Mail. Click here.