|
|
a complete fm receiver example 2 shows a somewhat simplified but complete broadcast fm receiver. it includes control of the rf front end and all required signal processing. this example uses an rf front end built from a cable modem tuner and a 20m sample/sec analog-to-digital converter. - example 2. broadcast fm receiver
- #!/usr/bin/env python
- from gnuradio import gr
- from gnuradio import audio
- from gnuradio import mc4020
- import sys
- def high_speed_adc (fg, input_rate):
- # return gr.file_source (gr.sizeof_short, "dummy.dat", false)
- return mc4020.source (input_rate, mc4020.mcc_ch3_en | mc4020.mcc_all_1v)
- #
- # return a gr.flow_graph
- #
- def build_graph (freq1, freq2):
- input_rate = 20e6
- cfir_decimation = 125
- audio_decimation = 5
- quad_rate = input_rate / cfir_decimation
- audio_rate = quad_rate / audio_decimation
- fg = gr.flow_graph ()
-
- # use high speed adc as input source
- src = high_speed_adc (fg, input_rate)
-
- # compute fir filter taps for channel selection
- channel_coeffs = \
- gr.firdes.low_pass (1.0, # gain
- input_rate, # sampling rate
- 250e3, # low pass cutoff freq
- 8*100e3, # width of trans. band
- gr.firdes.win_hamming)
- # input: short; output: complex
- chan_filter1 = \
- gr.freq_xlating_fir_filter_scf (cfir_decimation,
- channel_coeffs,
- freq1, # 1st station freq
- input_rate)
-
- (head1, tail1) = build_pipeline (fg, quad_rate, audio_decimation)
-
- # sound card as final sink
- audio_sink = audio.sink (int (audio_rate))
- # now wire it all together
- fg.connect (src, chan_filter1)
- fg.connect (chan_filter1, head1)
- fg.connect (tail1, (audio_sink, 0))
- return fg
- def build_pipeline (fg, quad_rate, audio_decimation):
- '''given a flow_graph, fg, construct a pipeline
- for demodulating a broadcast fm signal. the
- input is the downconverted complex baseband
- signal. the output is the demodulated audio.
- build_pipeline returns a two element tuple
- containing the input and output endpoints.
- '''
- fm_demod_gain = 2200.0/32768.0
- audio_rate = quad_rate / audio_decimation
- volume = 1.0
- # input: complex; output: float
- fm_demod = gr.quadrature_demod_cf (volume*fm_demod_gain)
- # compute fir filter taps for audio filter
- width_of_transition_band = audio_rate / 32
- audio_coeffs = gr.firdes.low_pass (1.0, # gain
- quad_rate, # sampling rate
- audio_rate/2 - width_of_transition_band,
- width_of_transition_band,
- gr.firdes.win_hamming)
- # input: float; output: float
- audio_filter = gr.fir_filter_fff (audio_decimation, audio_coeffs)
- fg.connect (fm_demod, audio_filter)
- return ((fm_demod, 0), (audio_filter, 0))
-
- def main (args):
- nargs = len (args)
- if nargs == 1:
- # get station frequency from command line
- freq1 = float (args[0]) * 1e6
- else:
- sys.stderr.write ('usage: fm_demod freq\n')
- sys.exit (1)
- # connect to rf front end
- rf_front_end = gr.microtune_4937_eval_board ()
- if not rf_front_end.board_present_p ():
- raise ioerror, 'rf front end not found'
- # set front end gain
- rf_front_end.set_agc (300)
- # determine the front end's "intermediate frequency"
- if_freq = rf_front_end.get_output_freq () # 5.75e6
- # tell the front end to tune to freq1.
- # i.e., freq1 is translated down to the if frequency
- rf_front_end.set_rf_freq (freq1)
- # build the flow graph
- fg = build_graph (if_freq, none)
-
- fg.start () # fork thread(s) and return
- raw_input ('press enter to quit: ')
- fg.stop ()
- if __name__ == '__main__':
- main (sys.argv[1:])
like the hello world example, we build a graph, connect the blocks together and start it. in this case, our source, mc4020.source, is an interface to the measurement computing pci-das 4020/12 high-speed adc. we follow it with gr.freq_xlating_fir_filter_scf, a finite impulse response (fir) filter that selects the fm station we're looking for and translates it to baseband (0hz, dc). with the 20m sample/sec converter and cable modem tuner, we're really grabbing something in the neighborhood of a 6 mhz chunk of the spectrum. this single chunk may contain ten or more fm stations, and gr.freq_xlating_fir_filter_scf allows us to select the one we want. in this case, we select the one at the exact center of the if of the rf front end (5.75 mhz). the output of gr.freq_xlating_fir_filter_scf is a stream of complex samples at 160,000 samples/second. we feed the complex baseband signal into gr.quadrature_demod_cf, the block that does the actual fm demodulation. gr.quadrature_demod_cf works by subtracting the angle of each adjacent complex sample, effectively differentiating the frequency. the output of gr.quadrature_demod_cf contains the left-plus-right fm mono audio signal, the stereo pilot tone at 19khz, the left-minus-right stereo information centered at 38khz and any other sub-carriers above that. for this simplified receiver, we finish off by low pass filtering and decimating the stream, keeping only the left-plus-right audio information, and send that to the sound card at 32,000 samples/sec. for a more indepth look at how the fm receiver works, please see "listening to fm, step by step."
|
