7505l1.txt0100664000204600003300000000215110104770123011430 0ustar jillljeditListing 1. Quadrature Demodulator Header /* * Copyright 2004 Free Software Foundation, Inc. * * This file is part of GNU Radio * * GNU Radio is free software; you can redistribute * it and/or modify it under the terms of the GNU * General Public License as published by the Free * Software Foundation; either version 2, or (at * your option) any later version. */ #ifndef INCLUDED_GR_QUADRATURE_DEMOD_CF_H #define INCLUDED_GR_QUADRATURE_DEMOD_CF_H #include class gr_quadrature_demod_cf; typedef boost::shared_ptr gr_quadrature_demod_cf_sptr; gr_quadrature_demod_cf_sptr gr_make_quadrature_demod_cf (float gain); /* * quadrature demodulator: complex in, float out */ class gr_quadrature_demod_cf : public gr_sync_block { friend gr_quadrature_demod_cf_sptr gr_make_quadrature_demod_cf (float gain); gr_quadrature_demod_cf (float gain); float d_gain; public: int sync_work ( int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items); }; #endif /* INCLUDED_GR_QUADRATURE_DEMOD_CF_H */ 7505l2.txt0100664000204600003300000000263010104770224011435 0ustar jillljeditListing 2. Quadrature Demodulator Implementation /* * Copyright 2004 Free Software Foundation, Inc. * * This file is part of GNU Radio * * GNU Radio is free software; you can redistribute * it and/or modify it under the terms of the GNU * General Public License as published by the Free * Software Foundation; either version 2, or (at * your option) any later version. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include gr_quadrature_demod_cf::gr_quadrature_demod_cf ( float gain) : gr_sync_block ( "quadrature_demod_cf", gr_make_io_signature(1,1,sizeof (gr_complex)), gr_make_io_signature(1,1,sizeof (float))), d_gain (gain) { set_history (2); // provide 1 sample look ahead } gr_quadrature_demod_cf_sptr gr_make_quadrature_demod_cf (float gain) { return gr_quadrature_demod_cf_sptr ( new gr_quadrature_demod_cf (gain)); } int gr_quadrature_demod_cf::sync_work ( int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) { gr_complex *in = (gr_complex *) input_items[0]; float *out = (float *) output_items[0]; in++; // ensure that in[-1] is valid for (int i = 0; i < noutput_items; i++){ gr_complex product = in[i] * conj (in[i-1]); out[i] = d_gain * arg (product); } return noutput_items; } 7505l3.txt0100775000204600003300000001025210070121645011437 0ustar jillljeditListing 3. Multi-channel FM Receiver #!/usr/bin/env python from gnuradio import gr import sys # # 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 = gr.high_speed_adc (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 = gr.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)) # two stations at once? if freq2: # Extract the second station and connect # it to a second pipeline... # input: short; output: complex chan_filter2 = \ gr.freq_xlating_fir_filter_scf ( cfir_decimation, channel_coeffs, freq2, # 2nd station freq input_rate) (head2, tail2) = \ build_pipeline (fg, quad_rate, audio_decimation) fg.connect (src, chan_filter2) fg.connect (chan_filter2, head2) fg.connect (tail2, (audio_sink, 1)) 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 downconverteed 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 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: freq1 = float (args[0]) * 1e6 freq2 = None elif nargs == 2: freq1 = float (args[0]) * 1e6 freq2 = float (args[1]) * 1e6 else: sys.stderr.write ( 'usage: fm_demod freq1 [freq2]\n') sys.exit (1) # connect to RF front end rf_front_end = gr.microtune_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) IF_freq = rf_front_end.get_output_freq () IF_freq = 5.75e6 if not freq2: # one station rf_front_end.set_RF_freq (freq1) fg = build_graph (IF_freq, None) else: # two stations if abs (freq1 - freq2) > 5.5e6: raise IOError, 'freqs too far apart' target_freq = (freq1 + freq2) / 2 actual_freq = \ rf_front_end.set_RF_freq (target_freq) fg = build_graph (IF_freq+freq1-actual_freq, IF_freq+freq2-actual_freq) fg.start () # fork thread(s) and return raw_input ('Press Enter to quit: ') fg.stop () if __name__ == '__main__': main (sys.argv[1:])